rubocop 1.79.2 → 1.87.0

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for places where a subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a range
+      # check, and suggests `grep` or `grep_v` instead.
+      #
+      # NOTE: Hashes do not behave as you may expect with `grep`, which
+      # means that `hash.grep` is not equivalent to `hash.select`. Although
+      # RuboCop is limited by static analysis, this cop attempts to avoid
+      # registering an offense when the receiver is a hash (hash literal,
+      # `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the cop cannot guarantee
+      #   that the receiver is actually an array by static analysis, so the
+      #   correction may not be actually equivalent.
+      #
+      # @example
+      #   # bad (select or find_all)
+      #   array.select { |x| x.between?(1, 10) }
+      #   array.select { |x| (1..10).cover?(x) }
+      #   array.select { |x| (1..10).include?(x) }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.between?(1, 10) }
+      #
+      #   # bad (find or detect)
+      #   array.find { |x| x.between?(1, 10) }
+      #   array.detect { |x| (1..10).cover?(x) }
+      #
+      #   # bad (negative form)
+      #   array.reject { |x| !x.between?(1, 10) }
+      #   array.find { |x| !(1..10).cover?(x) }
+      #
+      #   # good
+      #   array.grep(1..10)
+      #   array.grep_v(1..10)
+      #   array.grep(1..10).first
+      #   array.grep_v(1..10).first
+      class SelectByRange < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a range check.'
+        RESTRICT_ON_SEND = %i[select filter find_all reject find detect].freeze
+        SELECT_METHODS = %i[select filter find_all].freeze
+        FIND_METHODS = %i[find detect].freeze
+
+        # @!method range_check?(node)
+        # Matches: x.between?(min, max) or (min..max).cover?(x) or (min..max).include?(x)
+        def_node_matcher :range_check?, <<~PATTERN
+          {
+            (block call (args (arg $_)) ${(send (lvar _) :between? _ _)})
+            (block call (args (arg $_)) ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (block call (args (arg $_)) ${(send (send (lvar _) :between? _ _) :!)})
+            (block call (args (arg $_)) ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (block call (args (arg $_)) ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (block call (args (arg $_)) ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+            (numblock call $1 ${(send (lvar _) :between? _ _)})
+            (numblock call $1 ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (numblock call $1 ${(send (send (lvar _) :between? _ _) :!)})
+            (numblock call $1 ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (numblock call $1 ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (numblock call $1 ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+            (itblock call $_ ${(send (lvar _) :between? _ _)})
+            (itblock call $_ ${(send {range (begin range)} {:cover? :include?} (lvar _))})
+            (itblock call $_ ${(send (send (lvar _) :between? _ _) :!)})
+            (itblock call $_ ${(send (send {range (begin range)} {:cover? :include?} (lvar _)) :!)})
+            (itblock call $_ ${(send (begin (send (lvar _) :between? _ _)) :!)})
+            (itblock call $_ ${(send (begin (send {range (begin range)} {:cover? :include?} (lvar _))) :!)})
+          }
+        PATTERN
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
+          }
+        PATTERN
+
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, <<~PATTERN
+          (const {nil? cbase} :ENV)
+        PATTERN
+
+        # @!method between_call?(node, name)
+        def_node_matcher :between_call?, <<~PATTERN
+          (send (lvar %1) :between? _ _)
+        PATTERN
+
+        # @!method range_cover_call?(node, name)
+        def_node_matcher :range_cover_call?, <<~PATTERN
+          (send {range (begin range)} {:cover? :include?} (lvar %1))
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body&.begin_type?
+          return if receiver_allowed?(block_node.receiver)
+          return unless (range_check_send_node = extract_send_node(block_node))
+
+          replacement = replacement(range_check_send_node, node)
+          range_literal = find_range(range_check_send_node)
+
+          register_offense(node, block_node, range_literal, replacement)
+        end
+        alias on_csend on_send
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node) || env_const?(node)
+        end
+
+        def replacement(range_check_send_node, node)
+          negated = negated?(range_check_send_node)
+          method_name = node.method_name
+
+          if SELECT_METHODS.include?(method_name)
+            negated ? 'grep_v' : 'grep'
+          elsif FIND_METHODS.include?(method_name)
+            negated ? 'grep_v(...).first' : 'grep(...).first'
+          else # reject
+            negated ? 'grep' : 'grep_v'
+          end
+        end
+
+        def register_offense(node, block_node, range_literal, replacement)
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            if range_literal
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              grep_method = replacement.include?('grep_v') ? 'grep_v' : 'grep'
+              suffix = replacement.include?('.first') ? '.first' : ''
+              corrector.replace(range, "#{grep_method}(#{range_literal})#{suffix}")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, range_check_send_node = range_check?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
+
+          inner_node = unwrap_negation(range_check_send_node)
+
+          range_check_send_node if calls_lvar_in_range_check?(inner_node, block_arg_name)
+        end
+
+        def calls_lvar_in_range_check?(node, block_arg_name)
+          between_call?(node, block_arg_name) || range_cover_call?(node, block_arg_name)
+        end
+
+        def negated?(range_check_send_node)
+          range_check_send_node.send_type? && range_check_send_node.method?(:!)
+        end
+
+        def unwrap_negation(node)
+          if node.send_type? && node.method?(:!)
+            receiver = node.receiver
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver
+          else
+            node
+          end
+        end
+
+        def find_range(node)
+          inner = unwrap_negation(node)
+
+          if inner.method?(:between?)
+            # x.between?(min, max) -> min..max
+            min = inner.first_argument.source
+            max = inner.arguments[1].source
+            "#{min}..#{max}"
+          else
+            # (min..max).cover?(x) or (min..max).include?(x)
+            receiver = inner.receiver
+            # Unwrap begin node from parentheses
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver.source
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,6 +39,9 @@ module RuboCop
       #   array.reject { |x| x =~ /regexp/ }
       #   array.reject { |x| /regexp/ =~ x }
       #
+      #   # bad (negative form)
+      #   array.reject { |x| !x.match? /regexp/ }
+      #
       #   # good
       #   array.grep(regexp)
       #   array.grep_v(regexp)
@@ -48,18 +51,19 @@ module RuboCop
 
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
         RESTRICT_ON_SEND = %i[select filter find_all reject].freeze
-        REPLACEMENTS = { select: 'grep', filter: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        OPPOSITE_REPLACEMENTS = {
-          select: 'grep_v', filter: 'grep_v', find_all: 'grep_v', reject: 'grep'
-        }.freeze
-        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
+        SELECT_METHODS = %i[select filter find_all].freeze
+        REGEXP_METHODS = %i[match? =~].to_set.freeze
+        REGEXP_METHODS_NEGATED = %i[!~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
           {
-            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
-            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (block call (args (arg $_)) ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (numblock call $1 ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) (send _ %REGEXP_METHODS_NEGATED _) match-with-lvasgn})
+            (itblock call $_ ${(send (send _ %REGEXP_METHODS _) :!) (send (begin (send _ %REGEXP_METHODS _)) :!) (send match-with-lvasgn :!) (send (begin match-with-lvasgn) :!)})
           }
         PATTERN
 
@@ -84,6 +88,12 @@ module RuboCop
             (send (lvar %1) ...)
             (send ... (lvar %1))
             (match-with-lvasgn regexp (lvar %1))
+            (send (send (lvar %1) ...) :!)
+            (send (send ... (lvar %1)) :!)
+            (send (match-with-lvasgn regexp (lvar %1)) :!)
+            (send (begin (send (lvar %1) ...)) :!)
+            (send (begin (send ... (lvar %1))) :!)
+            (send (begin (match-with-lvasgn regexp (lvar %1))) :!)
           }
         PATTERN
 
@@ -97,7 +107,7 @@ module RuboCop
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
           replacement = replacement(regexp_method_send_node, node)
-          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+          return if target_ruby_version <= 2.2 && replacement.include?('grep_v')
 
           regexp = find_regexp(regexp_method_send_node, block_node)
 
@@ -115,11 +125,14 @@ module RuboCop
         end
 
         def replacement(regexp_method_send_node, node)
-          opposite = opposite?(regexp_method_send_node)
-
+          negated = negated?(regexp_method_send_node)
           method_name = node.method_name
 
-          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+          if SELECT_METHODS.include?(method_name)
+            negated ? 'grep_v' : 'grep'
+          else # reject
+            negated ? 'grep' : 'grep_v'
+          end
         end
 
         def register_offense(node, block_node, regexp, replacement)
@@ -138,30 +151,47 @@ module RuboCop
           return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
 
           block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          block_arg_name = :it if block_node.type?(:itblock)
 
           return unless calls_lvar?(regexp_method_send_node, block_arg_name)
 
           regexp_method_send_node
         end
 
-        def opposite?(regexp_method_send_node)
-          regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
+        def negated?(regexp_method_send_node)
+          return true if regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!)
+
+          inner = unwrap_negation(regexp_method_send_node)
+          inner.send_type? && inner.method?(:!~)
+        end
+
+        def unwrap_negation(node)
+          if node.send_type? && node.method?(:!)
+            receiver = node.receiver
+            receiver = receiver.children.first if receiver.begin_type?
+            receiver
+          else
+            node
+          end
         end
 
         def find_regexp(node, block)
-          return node.child_nodes.first if node.match_with_lvasgn_type?
+          inner = unwrap_negation(node)
+
+          return inner.child_nodes.first if inner.match_with_lvasgn_type?
 
-          if node.receiver.lvar_type? &&
+          if inner.receiver.lvar_type? &&
              (block.type?(:numblock, :itblock) ||
-              node.receiver.source == block.first_argument.source)
-            node.first_argument
-          elsif node.first_argument.lvar_type?
-            node.receiver
+              inner.receiver.source == block.first_argument.source)
+            inner.first_argument
+          elsif inner.first_argument&.lvar_type?
+            inner.receiver
           end
         end
 
         def match_predicate_without_receiver?(node)
-          node.send_type? && node.method?(:match?) && node.receiver.nil?
+          inner = unwrap_negation(node)
+          inner.send_type? && inner.method?(:match?) && inner.receiver.nil?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces the use the shorthand for self-assignment.
+      # Enforces the use of the shorthand for self-assignment.
       #
       # @example
       #

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Checks for multiple expressions placed on the same line.
       # It also checks for lines terminated with a semicolon.
+      # In idiomatic Ruby, each expression should be on its own line
+      # for readability.
       #
       # This cop has `AllowAsExpressionSeparator` configuration option.
       # It allows `;` to separate several expressions on the same line.
@@ -69,10 +71,11 @@ module RuboCop
 
         def each_semicolon
           tokens_for_lines.each do |line, tokens|
-            semicolon_pos = semicolon_position(tokens)
+            next unless (semicolon_pos = semicolon_position(tokens))
+
             after_expr_pos = semicolon_pos == -1 ? -2 : semicolon_pos
 
-            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos] if semicolon_pos
+            yield line, tokens[semicolon_pos].column, tokens[after_expr_pos]
           end
         end
 
@@ -119,6 +122,7 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -130,14 +134,19 @@ module RuboCop
               # without parentheses.
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
-                range_node = find_range_node(token_before_semicolon)
-                corrector.wrap(range_node, '(', ')') if range_node
+                node = find_node(range_nodes, token_before_semicolon)
+              elsif token_before_semicolon&.type == :tLABEL
+                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
+                space = node.parent.loc.selector.end.join(node.source_range.begin)
+                corrector.remove(space)
               end
 
+              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
@@ -153,9 +162,9 @@ module RuboCop
           end
         end
 
-        def find_range_node(token_before_semicolon)
-          range_nodes.detect do |range_node|
-            range_node.source_range.contains?(token_before_semicolon.pos)
+        def find_node(nodes, token_before_semicolon)
+          nodes.detect do |node|
+            node.source_range.overlaps?(token_before_semicolon.pos)
           end
         end
 
@@ -166,6 +175,15 @@ module RuboCop
           @range_nodes = ast.range_type? ? [ast] : []
           @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
+
+        def value_omission_pair_nodes
+          if instance_variable_defined?(:@value_omission_pair_nodes)
+            return @value_omission_pair_nodes
+          end
+
+          ast = processed_source.ast
+          @value_omission_pair_nodes = ast.each_descendant(:pair).to_a.select(&:value_omission?)
+        end
       end
     end
   end

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

@@ -33,7 +33,7 @@ module RuboCop
 
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return unless node.single_line?
 
           return unless eligible_method?(node)
@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def method_names
-          methods.map { |method| method_name(method).to_sym }
+          @method_names ||= methods.map { |method| method_name(method).to_sym }.freeze
         end
 
         def method_name(method)

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

@@ -38,7 +38,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_block(node)
-          return if !node.single_line? || node.braces?
+          return if node.multiline? || node.braces?
           return if single_line_blocks_preferred? && suitable_as_single_line?(node)
 
           add_offense(node) do |corrector|

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

@@ -4,7 +4,9 @@ module RuboCop
   module Cop
     module Style
       # Checks for single-line method definitions that contain a body.
-      # It will accept single-line methods with no body.
+      # Single-line methods with a body are harder to read and debug
+      # than their multi-line equivalents. It will accept single-line
+      # methods with no body.
       #
       # Endless methods added in Ruby 3.0 are also accepted by this cop.
       #

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

@@ -65,7 +65,10 @@ module RuboCop
 
           message = format(MSG, conditional_type: node.keyword)
           add_offense(if_branch.loc.keyword, message: message) do |corrector|
+            next if ignored_node?(node)
+
             autocorrect(corrector, node, if_branch)
+            ignore_node(if_branch)
           end
         end
 
@@ -115,9 +118,8 @@ module RuboCop
         end
 
         def correct_node(corrector, node)
-          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
+          corrector.replace(node.loc.keyword, 'if') if node.unless?
           corrector.replace(node.condition, chainable_condition(node))
-          ignore_node(node)
         end
 
         def correct_for_guard_condition_style(corrector, node, if_branch)
@@ -129,6 +131,7 @@ module RuboCop
           corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
+        # rubocop:disable Metrics/AbcSize
         def correct_for_basic_condition_style(corrector, node, if_branch)
           range = range_between(
             node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
@@ -137,8 +140,14 @@ module RuboCop
 
           corrector.replace(if_branch.condition, chainable_condition(if_branch))
 
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+          end_range = if same_line?(node.loc.end, node.if_branch.loc.end)
+                        node.loc.end
+                      else
+                        range_by_whole_lines(node.loc.end, include_final_newline: true)
+                      end
+          corrector.remove(end_range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
           correct_node(corrector, if_branch)

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

@@ -4,7 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Looks for uses of Perl-style global variables.
-      # Correcting to global variables in the 'English' library
+      # Perl-style global variables like `$;` or `$/` are cryptic
+      # and hard to understand without consulting documentation.
+      # The `English` library provides descriptive aliases like
+      # `$FIELD_SEPARATOR` and `$INPUT_RECORD_SEPARATOR`.
+      #
+      # Correcting to global variables in the `English` library
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.
       #

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

@@ -100,7 +100,7 @@ module RuboCop
           node.receiver.str_type? &&
             node.first_argument.str_type? &&
             node.multiline? &&
-            node.source =~ /\+\s*\n/
+            node.source.match?(/\+\s*\n/)
         end
 
         def find_topmost_plus_node(node)
@@ -141,22 +141,26 @@ module RuboCop
         end
 
         def replacement(parts)
-          interpolated_parts = parts.map do |part|
-            case part.type
-            when :str
-              adjust_str(part)
-            when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
-            else
-              "\#{#{part.source}}"
-            end
-          end
+          interpolated_parts = parts.map { |part| adjust_str(part) }
 
           "\"#{handle_quotes(interpolated_parts).join}\""
         end
 
-        def adjust_str(node)
-          single_quoted?(node) ? node.value.gsub(/(\\|")/, '\\\\\&') : node.value.inspect[1..-2]
+        def adjust_str(part)
+          case part.type
+          when :str
+            if single_quoted?(part)
+              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+            else
+              part.value.inspect[1..-2]
+            end
+          when :dstr, :begin
+            part.children.map do |child|
+              adjust_str(child)
+            end.join
+          else
+            "\#{#{part.source}}"
+          end
         end
 
         def handle_quotes(parts)

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

@@ -61,6 +61,8 @@ module RuboCop
             corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))
+          elsif unparenthesized_struct_new?(parent)
+            wrap_unparenthesized_call_with_do(corrector, parent)
           else
             corrector.insert_after(parent, ' do')
           end
@@ -73,6 +75,17 @@ module RuboCop
             range_by_whole_lines(class_node.loc.end, include_final_newline: true)
           end
         end
+
+        def unparenthesized_struct_new?(parent)
+          parent.send_type? && parent.arguments.any? && !parent.parenthesized?
+        end
+
+        def wrap_unparenthesized_call_with_do(corrector, parent)
+          args_source = parent.arguments.map(&:source).join(', ')
+          range = parent.loc.selector.end.join(parent.source_range.end)
+
+          corrector.replace(range, "(#{args_source}) do")
+        end
       end
     end
   end

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

@@ -109,7 +109,7 @@ module RuboCop
 
           def_args.zip(super_args).each do |def_arg, super_arg|
             next if positional_arg_same?(def_arg, super_arg)
-            next if positional_rest_arg_same(def_arg, super_arg)
+            next if positional_rest_arg_same?(def_arg, super_arg)
             next if keyword_arg_same?(def_arg, super_arg)
             next if keyword_rest_arg_same?(def_arg, super_arg)
             next if block_arg_same?(def_node, super_node, def_arg, super_arg)
@@ -147,7 +147,7 @@ module RuboCop
           def_arg.name == super_arg.children.first
         end
 
-        def positional_rest_arg_same(def_arg, super_arg)
+        def positional_rest_arg_same?(def_arg, super_arg)
           return false unless def_arg.restarg_type?
           # anonymous forwarding
           return true if def_arg.name.nil? && super_arg.forwarded_restarg_type?

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

@@ -81,7 +81,7 @@ module RuboCop
 
             content = *sym
             content = content.map { |c| c.is_a?(AST::Node) ? c.source : c }.join
-            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s\(\)]*\))/, '')
+            content_without_delimiter_pairs = content.gsub(/(\[[^\s\[\]]*\])|(\([^\s()]*\))/, '')
 
             content.include?(' ') || DELIMITERS.any? do |delimiter|
               content_without_delimiter_pairs.include?(delimiter)

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

@@ -179,7 +179,7 @@ module RuboCop
             return if allowed_method_name?(dispatch_node.method_name)
             return if allow_if_method_has_argument?(node.send_node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
-            return if allow_comments? && contains_comments?(node)
+            return if allow_comments?(node)
 
             register_offense(node, method_name, dispatch_node.method_name)
           end
@@ -260,10 +260,10 @@ module RuboCop
         end
 
         def begin_pos_for_replacement(node)
-          expr = node.send_node.source_range
+          send_node = node.send_node
 
-          if (paren_pos = (expr.source =~ /\(\s*\)$/))
-            expr.begin_pos + paren_pos
+          if send_node.parenthesized? && send_node.arguments.empty?
+            send_node.loc.begin.begin_pos
           else
             node.loc.begin.begin_pos
           end
@@ -273,8 +273,9 @@ module RuboCop
           !!cop_config.fetch('AllowMethodsWithArguments', false) && send_node.arguments.any?
         end
 
-        def allow_comments?
-          cop_config.fetch('AllowComments', false)
+        def allow_comments?(node)
+          cop_config.fetch('AllowComments', false) && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
         end
       end
     end