rubocop 1.71.1 → 1.92.0

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

@@ -13,17 +13,17 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Base
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
+        include ReparsedEquivalence
         extend AutoCorrector
 
-        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
 
         # @!method square_brackets?(node)
-        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
-
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
+        PATTERN
 
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
@@ -31,20 +31,43 @@ 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)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
         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) ||
-            allowed_expression?(node)
+            allowed_expression?(node) ||
+            ParenthesesCorrector.heredoc_strands_code_after_close_paren?(node)
         end
 
         def ignore_syntax?(node)
@@ -72,7 +95,7 @@ module RuboCop
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.type?(:begin, :def, :any_block)
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -92,7 +115,7 @@ module RuboCop
           return false unless node.type?(:send, :super, :yield)
 
           node.arguments.one? && !node.parenthesized? &&
-            !node.arithmetic_operation? && node.first_argument.begin_type?
+            !node.operator_method? && node.first_argument.begin_type?
         end
 
         def multiline_control_flow_statements?(node)
@@ -107,46 +130,52 @@ 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(:send).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)
 
-        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)
+          target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
         end
 
         def check(begin_node)
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message) if message == 'block body'
+
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
+              begin_node = begin_node.parent
+            end
+
             return offense(begin_node, message)
           end
 
-          check_send(begin_node, node) if node.call_type?
+          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 disallowed_literal?(begin_node, node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          return 'block body' if begin_node.parent&.any_block_type? || body_range?(begin_node, node)
+
           if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
             return 'an assignment'
           end
           if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
             return 'an expression'
           end
+          if disallowed_one_line_pattern_matching?(begin_node, node)
+            return 'a one-line pattern matching'
+          end
           return 'an interpolated expression' if interpolation?(begin_node)
+          if argument_of_parenthesized_method_call?(begin_node, node) &&
+             !keyword_logical_operator?(node)
+            return 'a method argument'
+          end
+          return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
           return if begin_node.chained?
 
@@ -154,6 +183,7 @@ module RuboCop
             return if node.semantic_operator? && begin_node.parent
             return if node.multiline? && allow_in_multiline_conditions?
             return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
             return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
@@ -163,41 +193,116 @@ 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]'
 
+        def argument_of_parenthesized_method_call?(begin_node, node)
+          if node.basic_conditional? || node.rescue_type? || method_call_parentheses_required?(node)
+            return false
+          end
+          return false unless (parent = begin_node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def oneline_rescue_parentheses_required?(begin_node, node)
+          return false unless node.rescue_type?
+          return false unless (parent = begin_node.parent)
+          return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
+
+          !parent.type?(:call, :array, :pair)
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
         def allow_in_multiline_conditions?
           !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end
 
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
         def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
           return check_unary(begin_node, node) if node.unary_operation?
+          return if setter_in_condition?(begin_node, node)
 
-          return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node) ||
-                    do_end_block_in_method_chain?(begin_node, node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
 
+        # Like a variable assignment, `if (foo.bar = baz)` is a safe assignment
+        # that `Lint/AssignmentInCondition` asks for, not redundant parentheses.
+        def setter_in_condition?(begin_node, node)
+          return false unless node.setter_method?
+          return false unless (parent = begin_node.parent)&.basic_conditional?
+
+          parent.condition.equal?(begin_node)
+        end
+
         def check_unary(begin_node, node)
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         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
@@ -207,18 +312,37 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
+          return true unless node.range_type?
+          return false unless (parent = begin_node.parent)
+
+          parent.begin_type? && parent.children.one?
         end
 
-        def raised_to_power_negative_numeric?(begin_node, node)
-          return false unless node.numeric_type?
+        # rubocop:disable-next Metrics/CyclomaticComplexity
+        def body_range?(begin_node, node)
+          return false if begin_node.chained?
+          return false unless node.range_type?
+          return false unless (parent = begin_node.parent)
+          return false unless parent.begin_type?
 
-          next_sibling = begin_node.right_sibling
-          return false unless next_sibling
+          (node.begin.nil? && begin_node == parent.children.first) ||
+            (node.end.nil? && begin_node == parent.children.last)
+        end
+
+        # `and`/`or` keyword operators bind looser than the method-argument
+        # boundary, so `foo((x and y))` cannot drop its parentheses without
+        # becoming a syntax error (unlike `&&`/`||`).
+        def keyword_logical_operator?(node)
+          node.operator_keyword? && node.semantic_operator?
+        end
 
-          base_value = node.children.first
+        def disallowed_one_line_pattern_matching?(begin_node, node)
+          if (parent = begin_node.parent)
+            return false if parent.any_def_type? && parent.endless?
+            return false if parent.assignment?
+          end
 
-          base_value.negative? && next_sibling == :**
+          node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
         end
 
         def keyword_with_redundant_parentheses?(node)
@@ -234,54 +358,23 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
+          return true if singular_parenthesized_parent?(begin_node)
 
-          send_node, args = method_node_and_args(node)
-
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
-        end
-
-        def only_begin_arg?(args)
-          args.one? && args.first&.begin_type?
-        end
-
-        def first_argument?(node)
-          if first_send_argument?(node) ||
-             first_super_argument?(node) ||
-             first_yield_argument?(node)
-            return true
-          end
-
-          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
         end
 
-        # @!method first_send_argument?(node)
-        def_node_matcher :first_send_argument?, <<~PATTERN
-          ^(send _ _ equal?(%0) ...)
-        PATTERN
+        def singular_parenthesized_parent?(begin_node)
+          return true unless (parent = begin_node.parent)
+          return false if parent.type?(:splat, :kwsplat)
 
-        # @!method first_super_argument?(node)
-        def_node_matcher :first_super_argument?, <<~PATTERN
-          ^(super equal?(%0) ...)
-        PATTERN
-
-        # @!method first_yield_argument?(node)
-        def_node_matcher :first_yield_argument?, <<~PATTERN
-          ^(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?(:+@))
+          parent.children.one?
         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?
+        def only_begin_arg?(args)
+          args.one? && args.first&.begin_type?
         end
       end
     end

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

@@ -80,8 +80,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
-            node.loc.begin && node.loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def start_with_percent_q_variant?(string)
@@ -91,7 +90,10 @@ module RuboCop
         def acceptable_q?(node)
           src = node.source
 
-          return true if STRING_INTERPOLATION_REGEXP.match?(src)
+          # If the string contains interpolation-like syntax and would be
+          # converted to a double-quoted string (because it contains single
+          # quotes), the replacement would activate interpolation.
+          return true if STRING_INTERPOLATION_REGEXP.match?(src) && src.include?(SINGLE_QUOTE)
 
           src.scan(/\\./).any?(ESCAPED_NON_BACKSLASH)
         end

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

@@ -66,6 +66,7 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable-next Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
@@ -73,6 +74,13 @@ module RuboCop
             new_argument.gsub!("'", "\\\\'")
             new_argument.gsub!('\"', '"')
             quote = "'"
+          elsif new_argument.include?("\\'")
+            # Add a backslash before single quotes preceded by an even number of backslashes.
+            # An even number (including zero) of backslashes before a quote means the quote itself
+            # is not escaped.
+            # Otherwise an odd number means the quote is already escaped so this doesn't touch it.
+            new_argument.gsub!(/(?<!\\)((?:\\\\)*)'/) { "#{::Regexp.last_match(1)}\\'" }
+            quote = "'"
           elsif new_argument.include?('\'')
             new_argument.gsub!("'", "\\\\'")
             quote = "'"
@@ -82,6 +90,8 @@ module RuboCop
             quote = enforce_double_quotes? ? '"' : "'"
           end
 
+          new_argument = escape_interpolation_like_text(new_argument) if quote == '"'
+
           "#{quote}#{new_argument}#{quote}"
         end
 
@@ -101,6 +111,11 @@ module RuboCop
             char
           end.join
         end
+
+        # `#{`, `#$` and `#@` would start an interpolation in a double-quoted string.
+        def escape_interpolation_like_text(string)
+          string.gsub(/#(?=[{$@])/) { '\#' }
+        end
       end
     end
   end

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

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
+            backslash_b?(class_elem) || backreference_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,10 +104,11 @@ module RuboCop
           elem == '\b'
         end
 
-        def octal_requiring_char_class?(elem)
-          # The octal escapes \1 to \7 only work inside a character class
-          # because they would be a backreference outside it.
-          elem.match?(/\A\\[1-7]\z/)
+        def backreference_requiring_char_class?(elem)
+          # `\1` to `\9` only match a literal digit inside a character class;
+          # outside it they are backreferences (and a syntax error when the
+          # referenced group does not exist), so the class is not redundant.
+          elem.match?(/\A\\[1-9]\z/)
         end
 
         def requires_escape_outside_char_class?(elem)

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
-      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      # Checks for the instantiation of a regexp using a redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces it with a regexp literal which is the simplest and fastest.
       #
       # @example
       #
@@ -27,19 +27,39 @@ module RuboCop
         def_node_matcher :redundant_regexp_constructor, <<~PATTERN
           (send
             (const {nil? cbase} :Regexp) {:new :compile}
-            (regexp $... (regopt $...)))
+            $(regexp _* (regopt _*)))
         PATTERN
 
         def on_send(node)
-          return unless (regexp, regopt = redundant_regexp_constructor(node))
+          return unless (regexp = redundant_regexp_constructor(node))
 
           add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
-            pattern = regexp.map(&:source).join
-            regopt = regopt.join
+            next if ambiguous_slash_regexp?(node, regexp)
 
-            corrector.replace(node, "/#{pattern}/#{regopt}")
+            # Reuse the inner literal's own source so its delimiters are preserved.
+            # Forcing `/.../` would break patterns like `%r{foo/bar}` that contain
+            # an unescaped slash.
+            corrector.replace(node, regexp.source)
           end
         end
+
+        private
+
+        # `p / a/` and `p /=a/` parse as division, so a slash regexp starting
+        # with whitespace or `=` can't begin the first argument of a command.
+        def ambiguous_slash_regexp?(node, regexp)
+          return false unless regexp.slash_literal? && regexp.content.match?(/\A[\s=]/)
+
+          begin_pos = node.source_range.begin_pos
+
+          node.each_ancestor(:call).any? do |call|
+            command?(call) && call.first_argument.source_range.begin_pos == begin_pos
+          end
+        end
+
+        def command?(call)
+          call.arguments? && !call.parenthesized? && !call.operator_method? && !call.setter_method?
+        end
       end
     end
   end

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

@@ -41,6 +41,11 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::RegexpLiteral]
+        end
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +69,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node, index, char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,6 +101,16 @@ module RuboCop
           delimiters.include?(char)
         end
 
+        def requires_escape_to_avoid_interpolation?(node, index, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'. `index` is relative to the regexp
+          # contents, so index into those rather than `node.source` (which also
+          # includes the opening delimiter, e.g. `%r{`).
+          return false unless index.positive? && INTERPOLATION_SIGILS.include?(escaped_char)
+
+          contents_range(node).source[index - 1] == '#'
+        end
+
         def each_escape(node)
           node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
             yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant `return` expressions.
+      # Checks for redundant `return` expressions. Ruby methods
+      # implicitly return the value of the last evaluated expression,
+      # so an explicit `return` at the end of a method body is unnecessary.
       #
       # @example
       #   # These bad cases should be extended to handle methods whose body is
@@ -106,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
 
@@ -122,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.rb

@@ -59,7 +59,7 @@ module RuboCop
 
         def initialize(config = nil, options = nil)
           super
-          @allowed_send_nodes = []
+          @allowed_send_nodes = Set.new.compare_by_identity
           @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }.compare_by_identity
         end
 
@@ -67,6 +67,9 @@ module RuboCop
 
         def on_or_asgn(node)
           allow_self(node.lhs)
+
+          lhs_name = node.lhs.lvasgn_type? ? node.lhs.name : node.lhs
+          add_lhs_to_local_variables_scopes(node.rhs, lhs_name)
         end
         alias on_and_asgn on_or_asgn
 
@@ -97,6 +100,15 @@ module RuboCop
           add_lhs_to_local_variables_scopes(node.rhs, node.lhs)
         end
 
+        # Register the exception variable of `rescue => e` so that `self.e` in the
+        # body is not treated as redundant (it disambiguates the local variable).
+        def on_resbody(node)
+          exception_variable = node.exception_variable
+          return unless exception_variable&.lvasgn_type?
+
+          @local_variables_scopes[node] << exception_variable.name
+        end
+
         def on_in_pattern(node)
           add_match_var_scopes(node)
         end
@@ -118,15 +130,16 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           # Allow conditional nodes to use `self` in the condition if that variable
           # name is used in an `lvasgn` or `masgn` within the `if`.
-          node.child_nodes.each do |child_node|
-            if child_node.lvasgn_type?
-              add_lhs_to_local_variables_scopes(node.condition, child_node.lhs)
-            elsif child_node.masgn_type?
-              add_masgn_lhs_variables(node.condition, child_node.lhs)
+          node.each_descendant(:lvasgn, :masgn) do |descendant_node|
+            if descendant_node.lvasgn_type?
+              add_lhs_to_local_variables_scopes(node.condition, descendant_node.lhs)
+            else
+              add_masgn_lhs_variables(node.condition, descendant_node.lhs)
             end
           end
         end
@@ -183,7 +196,7 @@ module RuboCop
         def allow_self(node)
           return unless node.send_type? && node.self_receiver?
 
-          @allowed_send_nodes << node
+          @allowed_send_nodes.add(node)
         end
 
         def add_lhs_to_local_variables_scopes(rhs, lhs)