rubocop 1.68.0 → 1.71.2

data/lib/rubocop/cop/style/file_touch.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usage of `File.open` in append mode with empty block.
+      #
+      # Such a usage only creates a new file, but it doesn't update
+      # timestamps for an existing file, which might have been the intention.
+      #
+      # For example, for an existing file `foo.txt`:
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100
+      #
+      #   ruby -e "File.open('foo.txt', 'a') {}"
+      #
+      #   ruby -e "puts File.mtime('foo.txt')"
+      #   # 2024-11-26 12:17:23 +0100 -> unchanged
+      #
+      # If the intention was to update timestamps, `FileUtils.touch('foo.txt')`
+      # should be used instead.
+      #
+      # @safety
+      #   Autocorrection is unsafe for this cop because unlike `File.open`,
+      #   `FileUtils.touch` updates an existing file's timestamps.
+      #
+      # @example
+      #   # bad
+      #   File.open(filename, 'a') {}
+      #   File.open(filename, 'a+') {}
+      #
+      #   # good
+      #   FileUtils.touch(filename)
+      #
+      class FileTouch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `FileUtils.touch(%<argument>s)` instead of `File.open` in ' \
+              'append mode with empty block.'
+
+        RESTRICT_ON_SEND = %i[open].freeze
+
+        APPEND_FILE_MODES = %w[a a+ ab a+b at a+t].to_set.freeze
+
+        # @!method file_open?(node)
+        def_node_matcher :file_open?, <<~PATTERN
+          (send
+            (const {nil? cbase} :File) :open
+            $(...)
+            (str %APPEND_FILE_MODES))
+        PATTERN
+
+        def on_send(node)
+          filename = file_open?(node)
+          parent = node.parent
+
+          return unless filename
+          return unless parent && empty_block?(parent)
+
+          message = format(MSG, argument: filename.source)
+          add_offense(parent, message: message) do |corrector|
+            corrector.replace(parent, "FileUtils.touch(#{filename.source})")
+          end
+        end
+
+        private
+
+        def empty_block?(node)
+          node.block_type? && !node.body
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/float_division.rb

@@ -65,19 +65,23 @@ module RuboCop
 
         # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
-          (send _ :/ (send _ :to_f))
+          (send _ :/ #to_f_method?)
         PATTERN
         # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ _)
+          (send #to_f_method? :/ _)
         PATTERN
         # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ (send _ :to_f))
+          (send #to_f_method? :/ #to_f_method?)
         PATTERN
         # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
-          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+          {(send _ :/ #to_f_method?) (send #to_f_method? :/ _)}
+        PATTERN
+        # @!method to_f_method?(node)
+        def_node_matcher :to_f_method?, <<~PATTERN
+          (send !nil? :to_f)
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/for.rb

@@ -44,7 +44,6 @@ module RuboCop
       #
       class For < Base
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
         EACH_LENGTH = 'each'.length

data/lib/rubocop/cop/style/frozen_string_literal_comment.rb

@@ -151,7 +151,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL)
+            token.text.start_with?(FROZEN_STRING_LITERAL_REGEXP)
           end
         end
 

data/lib/rubocop/cop/style/global_vars.rb

@@ -70,9 +70,7 @@ module RuboCop
         end
 
         def check(node)
-          global_var, = *node
-
-          add_offense(node.loc.name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(node.name)
         end
       end
     end

data/lib/rubocop/cop/style/guard_clause.rb

@@ -264,7 +264,7 @@ module RuboCop
 
         def and_or_guard_clause?(guard_clause)
           parent = guard_clause.parent
-          parent.and_type? || parent.or_type?
+          parent.operator_keyword?
         end
 
         def too_long_for_single_line?(node, example)

data/lib/rubocop/cop/style/hash_conversion.rb

@@ -111,8 +111,7 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
-            node.or_type? || node.and_type?
+          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
         end
 
         def multi_argument(node)

data/lib/rubocop/cop/style/hash_each_methods.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of `each_key` and `each_value` Hash methods.
+      # Checks for uses of `each_key` and `each_value` `Hash` methods.
       #
       # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
@@ -44,7 +44,7 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+          (any_block $(call (call _ ${:keys :values}) :each) ...)
         PATTERN
 
         # @!method each_arguments(node)
@@ -162,10 +162,7 @@ module RuboCop
 
         def use_array_converter_method_as_preceding?(node)
           return false unless (preceding_method = node.children.first.children.first)
-          unless preceding_method.call_type? ||
-                 preceding_method.block_type? || preceding_method.numblock_type?
-            return false
-          end
+          return false unless preceding_method.type?(:call, :any_block)
 
           ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
         end

data/lib/rubocop/cop/style/hash_except.rb

@@ -10,8 +10,10 @@ module RuboCop
       # (`Hash#except` was added in Ruby 3.0.)
       #
       # For safe detection, it is limited to commonly used string and symbol comparisons
-      # when used `==`.
-      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      # when using `==` or `!=`.
+      #
+      # This cop doesn't check for `Hash#delete_if` and `Hash#keep_if` because they
+      # modify the receiver.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -23,6 +25,9 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k.eql?(:bar) }
+      #
+      #   # bad
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].include?(k) }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].include?(k) }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[bar].include?(k) }
@@ -30,161 +35,44 @@ module RuboCop
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
       #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !k.in?(%i[bar]) }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !k.in?(%i[bar]) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.except(:bar)
+      #
       class HashExcept < Base
-        include RangeHelp
+        include HashSubset
         extend TargetRubyVersion
         extend AutoCorrector
 
         minimum_target_ruby_version 3.0
 
-        MSG = 'Use `%<prefer>s` instead.'
-        RESTRICT_ON_SEND = %i[reject select filter].freeze
-
-        # @!method bad_method_with_poro?(node)
-        def_node_matcher :bad_method_with_poro?, <<~PATTERN
-          (block
-            (call _ _)
-            (args
-              $(arg _)
-              (arg _))
-            {
-              $(send
-                _ {:== :!= :eql? :include?} _)
-              (send
-                $(send
-                  _ {:== :!= :eql? :include?} _) :!)
-              })
-        PATTERN
-
-        # @!method bad_method_with_active_support?(node)
-        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
-          (block
-            (send _ _)
-            (args
-              $(arg _)
-              (arg _))
-            {
-              $(send
-                _ {:== :!= :eql? :in? :include? :exclude?} _)
-              (send
-                $(send
-                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
-              })
-        PATTERN
-
-        def on_send(node)
-          method_name = node.method_name
-          block = node.parent
-          return unless bad_method?(method_name, block) && semantically_except_method?(node, block)
-
-          except_key = except_key(block)
-          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
-
-          range = offense_range(node)
-          preferred_method = "except(#{except_key_source(except_key)})"
-
-          add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
-            corrector.replace(range, preferred_method)
-          end
-        end
-        alias on_csend on_send
-
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(method_name, block)
-          if active_support_extensions_enabled?
-            bad_method_with_active_support?(block) do |key_arg, send_node|
-              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
-                return false
-              end
-              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
-
-              send_node.first_argument&.source == key_arg.source
-            end
-          else
-            bad_method_with_poro?(block) do |key_arg, send_node|
-              return false if method_name == :reject && block.body.method?(:!)
-
-              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
-            end
-          end
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        def semantically_except_method?(send, block)
-          body = block.body
-
-          negated = body.method?('!')
-          body = body.receiver if negated
-
-          case send.method_name
-          when :reject
-            body.method?('==') || body.method?('eql?') || included?(negated, body)
-          when :select, :filter
-            body.method?('!=') || not_included?(negated, body)
-          else
-            false
-          end
-        end
-
-        def included?(negated, body)
-          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
-        end
-
-        def not_included?(negated, body)
-          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
-        end
-
-        def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_negated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') ||
-             extracted.method?('exclude?')
-            return true
-          end
-          return true if block.body.method?('eql?')
-
-          except_key.sym_type? || except_key.str_type?
-        end
-
-        def extract_body_if_negated(body)
-          return body unless body.method?('!')
-
-          body.receiver
-        end
-
-        def except_key_source(key)
-          if key.array_type?
-            key = if key.percent_literal?
-                    key.each_value.map { |v| decorate_source(v) }
-                  else
-                    key.each_value.map(&:source)
-                  end
-            return key.join(', ')
-          end
-
-          key.literal? ? key.source : "*#{key.source}"
-        end
-
-        def decorate_source(value)
-          return ":\"#{value.source}\"" if value.dsym_type?
-          return "\"#{value.source}\"" if value.dstr_type?
-          return ":#{value.source}" if value.sym_type?
-
-          "'#{value.source}'"
-        end
-
-        def except_key(node)
-          key_argument = node.argument_list.first.source
-          body = extract_body_if_negated(node.body)
-          lhs, _method_name, rhs = *body
-          return if [lhs, rhs].map(&:source).none?(key_argument)
-
-          [lhs, rhs].find { |operand| operand.source != key_argument }
+        def semantically_subset_method?(node)
+          semantically_except_method?(node)
         end
 
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+        def preferred_method_name
+          'except'
         end
       end
     end

data/lib/rubocop/cop/style/hash_slice.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # that can be replaced with `Hash#slice` method.
+      #
+      # This cop should only be enabled on Ruby version 2.5 or higher.
+      # (`Hash#slice` was added in Ruby 2.5.)
+      #
+      # For safe detection, it is limited to commonly used string and symbol comparisons
+      # when using `==` or `!=`.
+      #
+      # This cop doesn't check for `Hash#delete_if` and `Hash#keep_if` because they
+      # modify the receiver.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.eql?(:bar) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| %i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !%i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| %i[bar].include?(k) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.slice(:bar)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !k.in?(%i[bar]) }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !k.in?(%i[bar]) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.slice(:bar)
+      #
+      class HashSlice < Base
+        include HashSubset
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 2.5
+
+        private
+
+        def semantically_subset_method?(node)
+          semantically_slice_method?(node)
+        end
+
+        def preferred_method_name
+          'slice'
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/hash_syntax.rb

@@ -137,6 +137,7 @@ module RuboCop
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
+        NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
         def on_hash(node)
           pairs = node.pairs
@@ -196,7 +197,7 @@ module RuboCop
         def autocorrect(corrector, node)
           if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
             autocorrect_hash_rockets(corrector, node)
-          elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+          elsif NO_MIXED_KEYS_STYLES.include?(style)
             autocorrect_no_mixed_keys(corrector, node)
           else
             autocorrect_ruby19(corrector, node)
@@ -208,7 +209,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.sym_type? || pair.key.dsym_type?
+          return false unless pair.key.type?(:sym, :dsym)
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end
@@ -272,7 +273,9 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
+          return false if !node.argument? || !node.parent.loc.selector
+
+          node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)

data/lib/rubocop/cop/style/identical_conditional_branches.rb

@@ -203,17 +203,36 @@ module RuboCop
               corrector.remove(range)
               next if inserted_expression
 
-              if insert_position == :after_condition
-                corrector.insert_after(node, "\n#{expression.source}")
+              if node.parent&.assignment?
+                correct_assignment(corrector, node, expression, insert_position)
               else
-                corrector.insert_before(node, "#{expression.source}\n")
+                correct_no_assignment(corrector, node, expression, insert_position)
               end
+
               inserted_expression = true
             end
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+        def correct_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
+            corrector.remove(assignment)
+            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+          else
+            corrector.insert_before(node.parent, "#{expression.source}\n")
+          end
+        end
+
+        def correct_no_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            corrector.insert_after(node, "\n#{expression.source}")
+          else
+            corrector.insert_before(node, "#{expression.source}\n")
+          end
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)
 

data/lib/rubocop/cop/style/if_inside_else.rb

@@ -59,7 +59,6 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -103,7 +103,7 @@ module RuboCop
 
         def defined_argument_is_undefined?(if_node, defined_node)
           defined_argument = defined_node.first_argument
-          return false unless defined_argument.lvar_type? || defined_argument.send_type?
+          return false unless defined_argument.type?(:lvar, :send)
 
           if_node.left_siblings.none? do |sibling|
             sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
@@ -112,11 +112,11 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.match_pattern_type? || condition.match_pattern_p_type?
+          if condition.type?(:match_pattern, :match_pattern_p)
             [condition]
           else
             condition.each_descendant.select do |node|
-              node.match_pattern_type? || node.match_pattern_p_type?
+              node.type?(:match_pattern, :match_pattern_p)
             end
           end
         end

data/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb

@@ -67,7 +67,7 @@ module RuboCop
 
         # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
-          (if #return_boolean_value? {(true) (false) | (false) (true)})
+          (if #return_boolean_value? <true false>)
         PATTERN
         # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
@@ -155,8 +155,7 @@ module RuboCop
         end
 
         def require_parentheses?(condition)
-          condition.and_type? || condition.or_type? ||
-            (condition.send_type? && condition.comparison_method?)
+          condition.operator_keyword? || (condition.send_type? && condition.comparison_method?)
         end
       end
     end

data/lib/rubocop/cop/style/if_with_semicolon.rb

@@ -23,6 +23,7 @@ module RuboCop
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
+          return if part_of_ignored_node?(node)
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
@@ -32,16 +33,17 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def message(node)
-          template = if node.if_branch&.begin_type?
+          template = if require_newline?(node)
                        MSG_NEWLINE
-                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
-                           use_block_in_branches?(node)
+                     elsif node.else_branch&.type?(:if, :begin) ||
+                           use_masgn_or_block_in_branches?(node)
                        MSG_IF_ELSE
                      else
                        MSG_TERNARY
@@ -49,18 +51,27 @@ module RuboCop
 
           format(template, expr: node.condition.source)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def autocorrect(corrector, node)
-          if node.branches.compact.any?(&:begin_type?) || use_block_in_branches?(node)
+          if require_newline?(node) || use_masgn_or_block_in_branches?(node)
             corrector.replace(node.loc.begin, "\n")
           else
             corrector.replace(node, replacement(node))
           end
         end
 
-        def use_block_in_branches?(node)
-          node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
+        def require_newline?(node)
+          node.branches.compact.any?(&:begin_type?) || use_return_with_argument?(node)
+        end
+
+        def use_masgn_or_block_in_branches?(node)
+          node.branches.compact.any? do |branch|
+            branch.type?(:masgn, :any_block)
+          end
+        end
+
+        def use_return_with_argument?(node)
+          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
         end
 
         def replacement(node)
@@ -111,7 +122,7 @@ module RuboCop
         end
 
         def require_argument_parentheses?(node)
-          return false unless node.call_type?
+          return false if !node.call_type? || node.arithmetic_operation?
 
           !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
         end