rubocop 1.88.2 → 1.90.0

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

@@ -15,6 +15,7 @@ module RuboCop
       #
       class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
+        include ReparsedEquivalence
         extend AutoCorrector
 
         ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
@@ -30,12 +31,30 @@ module RuboCop
         # @!method allowed_pin_operator?(node)
         def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
 
+        def on_new_investigation
+          @pending_offenses = {}.compare_by_identity
+          super
+        end
+
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
           check(node)
         end
 
+        def on_investigation_end
+          # Each candidate's exact correction is verified by reparsing before
+          # the offense is registered, so redundancy never depends on
+          # hand-maintained knowledge of Ruby's grammar.
+          verified_by_reparse(@pending_offenses.keys).each do |node|
+            add_offense(node, message: @pending_offenses[node]) do |corrector|
+              ParenthesesCorrector.correct(corrector, node)
+            end
+          end
+
+          super
+        end
+
         private
 
         def variable?(node)
@@ -44,7 +63,6 @@ module RuboCop
 
         def parens_allowed?(node)
           empty_parentheses?(node) ||
-            first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
             in_pattern_matching_in_method_argument?(node) ||
             allowed_pin_operator?(node) ||
@@ -111,15 +129,6 @@ module RuboCop
           node.children.empty?
         end
 
-        def first_arg_begins_with_hash_literal?(node)
-          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
-          if (root_method = node.each_ancestor(:call).to_a.last)
-            parenthesized = root_method.parenthesized_call?
-          end
-          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
-        end
-
         def in_pattern_matching_in_method_argument?(begin_node)
           return false unless begin_node.parent&.call_type?
           return false unless (node = begin_node.children.first)
@@ -127,14 +136,6 @@ module RuboCop
           target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
         end
 
-        def method_chain_begins_with_hash_literal(node)
-          return if node.nil?
-          return node if node.hash_type?
-          return unless node.send_type?
-
-          method_chain_begins_with_hash_literal(node.children.first)
-        end
-
         def check(begin_node)
           node = begin_node.children.first
 
@@ -151,7 +152,7 @@ module RuboCop
           check_send(begin_node, node) if call_node?(node)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
           return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
@@ -188,7 +189,6 @@ module RuboCop
             'a comparison expression'
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
@@ -231,8 +231,6 @@ module RuboCop
           return check_unary(begin_node, node) if node.unary_operation?
 
           return unless method_call_with_redundant_parentheses?(begin_node, node)
-          return if call_chain_starts_with_int?(begin_node, node) ||
-                    do_end_block_in_method_chain?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
@@ -247,11 +245,50 @@ module RuboCop
         end
 
         def offense(node, msg)
-          add_offense(node, message: "Don't use parentheses around #{msg}.") do |corrector|
-            ParenthesesCorrector.correct(corrector, node)
+          @pending_offenses[node] = "Don't use parentheses around #{msg}."
+        end
+
+        def apply_reparse_correction(corrector, node)
+          ParenthesesCorrector.correct(corrector, node)
+        end
+
+        # Grouping parentheses are transparent to the comparison: single-child
+        # `begin` nodes are collapsed, a parenthesized statement sequence
+        # inside another sequence is spliced in place, and chains of the same
+        # `&&`/`||` operator are normalized to left association (`x && (y &&
+        # z)` and `x && y && z` differ as trees but `&&` and `||` cannot be
+        # redefined, so same-operator regrouping is semantically transparent).
+        def normalize_reparsed_ast(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| normalize_reparsed_ast(child) }
+          children = splice_nested_sequences(children) if %i[begin kwbegin].include?(node.type)
+
+          node = node.updated(nil, children)
+          if node.begin_type? && children.one? && children.first.is_a?(::Parser::AST::Node)
+            children.first
+          else
+            rotate_same_operator(node)
+          end
+        end
+
+        def splice_nested_sequences(children)
+          children.flat_map do |child|
+            child.is_a?(::Parser::AST::Node) && child.begin_type? ? child.children : [child]
           end
         end
 
+        def rotate_same_operator(node)
+          return node unless node.type?(:and, :or)
+
+          right = node.rhs
+          return node unless right.is_a?(::Parser::AST::Node) && right.type == node.type
+
+          rotated_left = rotate_same_operator(node.updated(nil, [node.lhs, right.lhs]))
+
+          rotate_same_operator(node.updated(nil, [rotated_left, right.rhs]))
+        end
+
         def suspect_unary?(node)
           node.send_type? && node.unary_operation? && !node.prefix_not?
         end
@@ -261,16 +298,13 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          if node.range_type?
-            return false unless (parent = begin_node.parent)
+          return true unless node.range_type?
+          return false unless (parent = begin_node.parent)
 
-            parent.begin_type? && parent.children.one?
-          else
-            !raised_to_power_negative_numeric?(begin_node, node)
-          end
+          parent.begin_type? && parent.children.one?
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def body_range?(begin_node, node)
           return false if begin_node.chained?
           return false unless node.range_type?
@@ -280,7 +314,6 @@ module RuboCop
           (node.begin.nil? && begin_node == parent.children.first) ||
             (node.end.nil? && begin_node == parent.children.last)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def disallowed_one_line_pattern_matching?(begin_node, node)
           if (parent = begin_node.parent)
@@ -291,17 +324,6 @@ module RuboCop
           node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
         end
 
-        def raised_to_power_negative_numeric?(begin_node, node)
-          return false unless node.numeric_type?
-
-          next_sibling = begin_node.right_sibling
-          return false unless next_sibling
-
-          base_value = node.children.first
-
-          base_value.negative? && next_sibling == :**
-        end
-
         def keyword_with_redundant_parentheses?(node)
           return false unless node.keyword?
           return true if node.special_keyword?
@@ -333,30 +355,6 @@ module RuboCop
         def only_begin_arg?(args)
           args.one? && args.first&.begin_type?
         end
-
-        def first_argument?(node)
-          return true if first_call_argument?(node)
-
-          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
-        end
-
-        # @!method first_call_argument?(node)
-        def_node_matcher :first_call_argument?, <<~PATTERN
-          {^(call _ _ equal?(%0) ...)
-           ^({super yield} equal?(%0) ...)}
-        PATTERN
-
-        def call_chain_starts_with_int?(begin_node, send_node)
-          recv = first_part_of_call_chain(send_node)
-          recv&.int_type? && (parent = begin_node.parent) &&
-            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
-        end
-
-        def do_end_block_in_method_chain?(begin_node, node)
-          return false unless (block = node.each_descendant(:any_block).first)
-
-          block.keywords? && begin_node.each_ancestor(:call).any?
-        end
       end
     end
   end

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

@@ -66,7 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -92,7 +92,6 @@ module RuboCop
 
           "#{quote}#{new_argument}#{quote}"
         end
-        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

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

@@ -108,7 +108,7 @@ module RuboCop
           corrector.insert_after(node.children.last, '}')
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
@@ -124,7 +124,6 @@ module RuboCop
             check_begin_node(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
           return if cop_config['AllowMultipleReturnValues'] && node.children.size > 1

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

@@ -55,7 +55,7 @@ module RuboCop
               ...))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
           return unless rhs.type?(:any_block, :call) && method_returning_self?(rhs.method_name)
@@ -69,7 +69,6 @@ module RuboCop
             corrector.replace(node, rhs.source)
           end
         end
-        # rubocop:enable Metrics/AbcSize
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn

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

@@ -75,7 +75,7 @@ module RuboCop
           node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def allowed_escape?(node, range)
           escaped = range.source[(1..-1)]
 
@@ -95,7 +95,6 @@ module RuboCop
 
           false
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def interpolation_not_enabled?(node)
           single_quoted?(node) ||

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

@@ -67,7 +67,7 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def correct_rescue_block(corrector, node, parenthesized)
           operation = node.body
 
@@ -83,7 +83,6 @@ module RuboCop
             #{node_offset}end
           RESCUE_CLAUSE
         end
-        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)

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

@@ -37,6 +37,16 @@ module RuboCop
       #   x&.foo      # raises NoMethodError
       #   ----
       #
+      #   Additionally, when a method chain is converted, a `NoMethodError` that
+      #   the original code raised for an intermediate `nil` value is suppressed:
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = Struct.new(:foo).new(nil)
+      #   x && x.foo.bar  # raises NoMethodError
+      #   x&.foo&.bar     # returns nil
+      #   ----
+      #
       # @example
       #   # bad
       #   foo.bar if foo
@@ -142,7 +152,7 @@ module RuboCop
         # @!method strip_begin(node)
         def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return if allowed_if_condition?(node)
 
@@ -160,7 +170,6 @@ module RuboCop
             corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
           collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|

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

@@ -7,6 +7,10 @@ module RuboCop
       # `shuffle.last`, and `shuffle[]` and change them to use
       # `sample` instead.
       #
+      # NOTE: An offense involving a `random:` argument is registered but not autocorrected:
+      # `shuffle` and `sample` consume the given generator differently, so for a seeded generator
+      # the correction would select different elements.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].shuffle.first
@@ -45,10 +49,12 @@ module RuboCop
             range = source_range(shuffle_node, node)
             message = message(shuffle_arg, method, method_args, range)
 
-            add_offense(range, message: message) do |corrector|
-              corrector.replace(
-                source_range(shuffle_node, node), correction(shuffle_arg, method, method_args)
-              )
+            if shuffle_arg.empty?
+              add_offense(range, message: message) do |corrector|
+                corrector.replace(range, correction(shuffle_arg, method, method_args))
+              end
+            else
+              add_offense(range, message: message)
             end
           end
         end
@@ -92,7 +98,7 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def range_size(range_node)
           vals = range_node.to_a
           return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
@@ -107,7 +113,6 @@ module RuboCop
             (low..high).size
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
           shuffle_node.loc.selector.join(node.source_range.end)

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

@@ -97,7 +97,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return if target_ruby_version < 2.6 && node.method?(:filter)
           return unless (block_node = node.block_node)
@@ -113,7 +113,6 @@ module RuboCop
 
           register_offense(node, block_node, regexp, replacement)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_csend on_send
 
         private

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

@@ -83,7 +83,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -100,7 +100,6 @@ module RuboCop
             -4
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -122,7 +121,7 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -146,7 +145,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def replace_semicolon_with_line_break(corrector, range)
           # Replacing the semicolon with a newline would move the rest of the

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

@@ -36,7 +36,7 @@ module RuboCop
 
         MSG = 'Prefer multiline `do`...`end` block.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_block(node)
           return if node.multiline? || node.braces?
           return if single_line_blocks_preferred? && suitable_as_single_line?(node)
@@ -55,7 +55,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
         alias on_itblock on_block
 

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

@@ -48,6 +48,7 @@ module RuboCop
       #   end if condition_a
       class SoleNestedConditional < Base
         include RangeHelp
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
@@ -57,11 +58,10 @@ module RuboCop
         end
 
         def on_if(node)
-          return if node.ternary? || node.else? || node.elsif?
+          return unless offending_conditional?(node)
 
           if_branch = node.if_branch
-          return if use_variable_assignment_in_condition?(node.condition, if_branch)
-          return unless offending_branch?(node, if_branch)
+          return unless correction_parses?(node)
 
           message = format(MSG, conditional_type: node.keyword)
           add_offense(if_branch.loc.keyword, message: message) do |corrector|
@@ -74,6 +74,23 @@ module RuboCop
 
         private
 
+        def offending_conditional?(node)
+          return false if node.ternary? || node.else? || node.elsif?
+
+          if_branch = node.if_branch
+          return false if use_variable_assignment_in_condition?(node.condition, if_branch)
+
+          offending_branch?(node, if_branch)
+        end
+
+        # Merging the conditionals intentionally produces a different AST, so
+        # full equivalence cannot be checked, but the corrected source must at
+        # least remain parseable (see `ReparsedEquivalence#correction_parses?`),
+        # which suppresses the entire produces-invalid-code bug class.
+        def apply_reparse_correction(corrector, node)
+          autocorrect(corrector, node, node.if_branch)
+        end
+
         def use_variable_assignment_in_condition?(condition, if_branch)
           assigned_variables = assigned_variables(condition)
 
@@ -131,7 +148,7 @@ module RuboCop
           corrector.remove(range_with_surrounding_space(range, newlines: false))
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next 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
@@ -147,7 +164,6 @@ module RuboCop
                       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/stabby_lambda_parentheses.rb

@@ -25,6 +25,8 @@ module RuboCop
 
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
         MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
+
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) || missing_parentheses?(node)

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

@@ -12,6 +12,11 @@ module RuboCop
       #   for some other subclass, monkey-patched with instance methods or
       #   a dummy instance is instantiated from it somewhere.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, classes that are subclassed anywhere in the project are
+      # not reported, since converting them to modules would break their
+      # subclasses.
+      #
       # @example
       #   # bad
       #   class SomeClass
@@ -44,6 +49,7 @@ module RuboCop
       #   end
       #
       class StaticClass < Base
+        include ProjectIndexHelp
         include RangeHelp
         include VisibilityHelp
         extend AutoCorrector
@@ -53,6 +59,7 @@ module RuboCop
         def on_class(class_node)
           return if class_node.parent_class
           return unless class_convertible_to_module?(class_node)
+          return if subclassed_in_project?(class_node)
 
           add_offense(class_node) do |corrector|
             autocorrect(corrector, class_node)
@@ -61,6 +68,20 @@ module RuboCop
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, a class with descendants
+        # anywhere in the project is not reported: converting it to a module
+        # would break its subclasses.
+        def subclassed_in_project?(class_node)
+          return false unless project_index
+
+          declaration = resolve_constant_in_index(class_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Class)
+
+          declaration.descendants.any? { |descendant| descendant.name != declaration.name }
+        rescue StandardError
+          false
+        end
+
         def autocorrect(corrector, class_node)
           corrector.replace(class_node.loc.keyword, 'module')
           corrector.insert_after(class_node.loc.name, "\nmodule_function\n")

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

@@ -149,11 +149,7 @@ module RuboCop
         def adjust_str(part)
           case part.type
           when :str
-            if single_quoted?(part)
-              part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
-            else
-              part.value.inspect[1..-2]
-            end
+            adjust_str_literal(part)
           when :dstr, :begin
             part.children.map do |child|
               adjust_str(child)
@@ -163,6 +159,19 @@ module RuboCop
           end
         end
 
+        def adjust_str_literal(part)
+          if single_quoted?(part)
+            part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
+          elsif double_quoted?(part)
+            # Reuse the source as written - rebuilding it from the value via
+            # `inspect` would rewrite the author's escape notation
+            # (e.g. `\x0a` into `\n`).
+            part.source[1..-2]
+          else
+            part.value.inspect[1..-2]
+          end
+        end
+
         def handle_quotes(parts)
           parts.map do |part|
             part == '"' ? '\"' : part
@@ -173,6 +182,10 @@ module RuboCop
           str_node.source.start_with?("'")
         end
 
+        def double_quoted?(str_node)
+          str_node.source.start_with?('"')
+        end
+
         def mode
           cop_config['Mode'].to_sym
         end

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

@@ -103,7 +103,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def arguments_identical?(def_node, super_node, def_args, super_args)
           return false if argument_list_size_differs?(def_args, super_args, super_node)
 
@@ -120,7 +120,6 @@ module RuboCop
 
           true
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def argument_list_size_differs?(def_args, super_args, super_node)
           # If the def node has a block argument and the super node has an explicit block,

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

@@ -167,7 +167,7 @@ module RuboCop
           [Layout::SpaceBeforeBlockBraces]
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             if active_support_extensions_enabled?
@@ -184,7 +184,6 @@ module RuboCop
             register_offense(node, method_name, dispatch_node.method_name)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
         alias on_itblock on_block