[Fix #12311] Fix false negatives for Style/RedundantParentheses

Fixes #12311.

This PR fixes false negatives for `Style/RedundantParentheses`
when parentheses around logical operator keywords in method definition.

changelog/fix_false_negatives_for_style_redundant_parentheses.md

@@ -0,0 +1 @@
+* [#12311](https://github.com/rubocop/rubocop/issues/12311): Fix false negatives for `Style/RedundantParentheses` when parentheses around logical operator keywords in method definition. ([@koic][])

lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -79,7 +79,7 @@ def aligned_token?(range, line)
       end
 
       def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+        aligned_identical?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_words?(range, line)

lib/rubocop/cop/style/redundant_parentheses.rb

@@ -17,6 +17,8 @@ class RedundantParentheses < Base
         include Parentheses
         extend AutoCorrector
 
+        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
 
@@ -144,11 +146,16 @@ def find_offense_message(begin_node, node)
           return 'a constant' if node.const_type?
           return 'an interpolated expression' if interpolation?(begin_node)
 
-          return if begin_node.chained? || !begin_node.parent.nil?
+          return if begin_node.chained?
 
           if node.and_type? || node.or_type?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
             'a comparison expression'
           end
         end

lib/rubocop/cop/style/redundant_string_escape.rb

@@ -133,7 +133,7 @@ def percent_w_upper_literal?(node)
         end
 
         def percent_array_literal?(node)
-          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+          percent_w_literal?(node) || percent_w_upper_literal?(node)
         end
 
         def heredoc_with_disabled_interpolation?(node)

spec/rubocop/cop/style/redundant_parentheses_spec.rb

@@ -493,15 +493,87 @@ def x
     expect_no_offenses('(a...b)')
   end
 
-  it 'accepts parentheses around logical operator keywords' do
+  it 'registers parentheses around `||` logical operator keywords in method definition' do
+    expect_offense(<<~RUBY)
+      def foo
+        (x || y)
+        ^^^^^^^^ Don't use parentheses around a logical expression.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      def foo
+        x || y
+      end
+    RUBY
+  end
+
+  it 'registers parentheses around `&&` logical operator keywords in method definition' do
+    expect_offense(<<~RUBY)
+      def foo
+        (x && y)
+        ^^^^^^^^ Don't use parentheses around a logical expression.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      def foo
+        x && y
+      end
+    RUBY
+  end
+
+  it 'accepts parentheses around arithmetic operator' do
+    expect_no_offenses('x - (y || z)')
+  end
+
+  it 'accepts parentheses around logical operator keywords (`and`, `and`, `or`)' do
     expect_no_offenses('(1 and 2) and (3 or 4)')
   end
 
+  it 'accepts parentheses around logical operator keywords (`or`, `or`, `and`)' do
+    expect_no_offenses('(1 or 2) or (3 and 4)')
+  end
+
   it 'accepts parentheses around comparison operator keywords' do
     # Parentheses are redundant, but respect user's intentions for readability.
     expect_no_offenses('x && (y == z)')
   end
 
+  it 'accepts parentheses around logical operator in splat' do
+    # Parentheses are redundant, but respect user's intentions for readability.
+    expect_no_offenses('x = *(y || z)')
+  end
+
+  it 'accepts parentheses around logical operator in double splat' do
+    # Parentheses are redundant, but respect user's intentions for readability.
+    expect_no_offenses('x(**(y || z))')
+  end
+
+  it 'accepts parentheses around logical operator in ternary operator' do
+    # Parentheses are redundant, but respect user's intentions for readability.
+    expect_no_offenses('cond ? x : (y || z)')
+  end
+
+  it 'registers parentheses around logical operator in `if`...`else`' do
+    expect_offense(<<~RUBY)
+      if cond
+        x
+      else
+        (y || z)
+        ^^^^^^^^ Don't use parentheses around a logical expression.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      if cond
+        x
+      else
+        y || z
+      end
+    RUBY
+  end
+
   it 'accepts parentheses around a method call with parenthesized logical expression receiver' do
     expect_no_offenses('(x || y).z')
   end