rubocop 1.87.0 → 1.88.2

data/lib/rubocop/cop/lint/useless_numeric_operation.rb

@@ -36,31 +36,31 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, <<~PATTERN
+          (call ${lvar ivar cvar gvar const (send nil? _)} $_ (int $_))
+        PATTERN
 
         # @!method useless_abbreviated_assignment?(node)
-        def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
+        def_node_matcher :useless_abbreviated_assignment?, <<~PATTERN
+          (op-asgn ${lvasgn ivasgn cvasgn gvasgn casgn} $_ (int $_))
+        PATTERN
 
         def on_send(node)
-          return unless useless_operation?(node)
-
-          variable, operation, number = useless_operation?(node)
+          return unless (receiver, operation, number = useless_operation?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, variable)
+            corrector.replace(node, receiver.source)
           end
         end
         alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless useless_abbreviated_assignment?(node)
-
-          variable, operation, number = useless_abbreviated_assignment?(node)
+          return unless (variable, operation, number = useless_abbreviated_assignment?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{variable}")
+            corrector.replace(node, "#{variable.source} = #{variable.source}")
           end
         end
 

data/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -107,11 +107,15 @@ module RuboCop
         end
 
         def find_method_definition(node, method_name)
-          node.each_ancestor.lazy.map do |ancestor|
-            ancestor.each_child_node(:def, :any_block).find do |child|
+          node.each_ancestor do |ancestor|
+            found = ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
-          end.find(&:itself)
+            return found if found
+            # A method defined in an outer lexical scope does not define this scope's method,
+            # so stop searching once a class/module boundary is crossed without a match.
+            return nil if ancestor.type?(:class, :module, :sclass)
+          end
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -107,7 +107,10 @@ module RuboCop
           end
 
           def process_multiple_assignment(masgn_node)
-            masgn_node.assignments.each_with_index do |lhs_node, index|
+            # Iterate the top-level destructuring slots so each maps to the right-hand side
+            # element at the same position. Using the flattened `assignments` would misalign
+            # the index when a slot is itself a nested destructuring (e.g. `(a, b), c = x, y`).
+            masgn_node.lhs.children.each_with_index do |lhs_node, index|
               next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
               if masgn_node.rhs.array_type? && (rhs_node = masgn_node.rhs.children[index])

data/lib/rubocop/cop/lint/useless_times.rb

@@ -83,7 +83,7 @@ module RuboCop
 
         def autocorrect_block(corrector, node)
           block_arg = block_arg(node)
-          return if block_reassigns_arg?(node, block_arg)
+          return unless reducible_to_body?(node, block_arg)
 
           source = node.body.source
           source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
@@ -91,6 +91,27 @@ module RuboCop
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end
 
+        def reducible_to_body?(node, block_arg)
+          # A block with multiple arguments can't be reduced to its body (the extra arguments
+          # would become undefined references), and `next`/`break`/`redo` bound to the block
+          # become orphaned (a syntax error) once the block is removed.
+          return false if node.arguments.size > 1 || orphans_loop_control_keyword?(node)
+
+          # A lone non-simple argument (destructuring `|(a, b)|` or a splat `|*a|`) can't be
+          # substituted either, so reducing to the body would leave it referencing an
+          # undefined variable.
+          return false if node.arguments.one? && block_arg.nil?
+
+          !block_reassigns_arg?(node, block_arg)
+        end
+
+        def orphans_loop_control_keyword?(node)
+          node.body&.each_node(:next, :break, :redo)&.any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.type?(:any_block, :while, :until, :for) }
+          end
+        end
+
         def fix_indentation(source, range)
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")

data/lib/rubocop/cop/lint/void.rb

@@ -212,7 +212,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return unless node.type?(:send, :any_block)
+          return unless node.type?(:call, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -265,7 +265,7 @@ module RuboCop
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)
-          send_node = if node.send_type?
+          send_node = if node.call_type?
                         node
                       else
                         node.send_node

data/lib/rubocop/cop/metrics/collection_literal_length.rb

@@ -75,7 +75,7 @@ module RuboCop
         private
 
         def collection_threshold
-          cop_config.fetch('LengthThreshold', Float::INFINITY)
+          cop_config.fetch('Max', Float::INFINITY)
         end
       end
     end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -58,7 +58,7 @@ module RuboCop
           return unless node.method?(:define_method)
 
           method_name = node.send_node.first_argument
-          return if method_name.basic_literal? && allowed?(method_name.value)
+          return if method_name&.basic_literal? && allowed?(method_name.value)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -12,9 +12,15 @@ module RuboCop
       # nodes count. In contrast to the CyclomaticComplexity cop, this cop
       # considers `else` nodes as adding complexity.
       #
+      # A `case`/`in` branch whose pattern is a simple literal (e.g. `in 1`, `in "red"`, `in 1..10`)
+      # or a constant/type (e.g. `in Integer`) and has no guard is just as easy to read as a `when`
+      # branch, so it is discounted the same way. Branches with structural patterns (e.g. array,
+      # hash, or find patterns), bindings, alternatives, or a guard add the full complexity of
+      # a decision point.
+      #
       # @example
       #
-      #   def my_method                   # 1
+      #   def example_1                   # 1
       #     if cond                       # 1
       #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
       #       when 1 then func_one
@@ -26,33 +32,58 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
+      #
+      #   def example_2                   # 1
+      #     case color                    # 1 (3 * 0.2, rounded)
+      #     in "red" then func_red
+      #     in "blue" then func_blue
+      #     in "green" then func_green
+      #     end                           # ===
+      #   end                             # 2 complexity points
       class PerceivedComplexity < CyclomaticComplexity
         MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
-        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
+        COUNTED_NODES = (
+          CyclomaticComplexity::COUNTED_NODES - %i[when in_pattern] + %i[case case_match]
+        ).freeze
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def complexity_score_for(node)
           case node.type
           when :case
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
+            # If cond is nil, that means each when has an expression that evaluates to true or
+            # false. It's just an alternative to if/elsif/elsif... so the when nodes count.
             nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
               nb_branches
             else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
+              # Otherwise, the case node gets 0.8 complexity points and each when gets 0.2.
               ((nb_branches * 0.2) + 0.8).round
             end
+          when :case_match
+            # Simple `in` branches are discounted like `when`, while structural patterns keep
+            # the full complexity of a decision point.
+            score = node.in_pattern_branches.sum { |branch| simple_in_pattern?(branch) ? 0.2 : 1 }
+            score += 0.2 if node.else_branch
+            score.round
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
             super
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def simple_in_pattern?(in_pattern_node)
+          # `in_pattern_node.children[1]` is the guard (`if`/`unless`), or `nil`.
+          return false unless in_pattern_node.children[1].nil?
+
+          # A scalar literal, a literal range, or a constant/type is as easy to read as a `when`.
+          pattern = in_pattern_node.pattern
+          pattern.literal? || pattern.const_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -25,11 +25,11 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        if cop_config_deprecated_values.any?(Regexp)
-          cop_config_allowed_methods
-        else
-          cop_config_allowed_methods + cop_config_deprecated_values
-        end
+        @allowed_methods ||= if cop_config_deprecated_values.any?(Regexp)
+                               cop_config_allowed_methods
+                             else
+                               cop_config_allowed_methods + cop_config_deprecated_values
+                             end
       end
 
       def cop_config_allowed_methods

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -27,7 +27,7 @@ module RuboCop
       end
 
       def matches_allowed_pattern?(line)
-        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+        allowed_pattern_regexps.any? { |pattern| pattern.match?(line) }
       end
 
       # @deprecated Use matches_allowed_pattern? instead
@@ -49,6 +49,10 @@ module RuboCop
         end
       end
 
+      def allowed_pattern_regexps
+        @allowed_pattern_regexps ||= allowed_patterns.map { |pattern| Regexp.new(pattern) }
+      end
+
       def cop_config_patterns_values
         @cop_config_patterns_values ||=
           Array(cop_config.fetch('AllowedPatterns', [])) +

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -5,12 +5,16 @@ module RuboCop
     # This module encapsulates the ability to forbid certain patterns in a cop.
     module ForbiddenPattern
       def forbidden_pattern?(name)
-        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        forbidden_pattern_regexps.any? { |pattern| pattern.match?(name) }
       end
 
       def forbidden_patterns
         cop_config.fetch('ForbiddenPatterns', [])
       end
+
+      def forbidden_pattern_regexps
+        @forbidden_pattern_regexps ||= forbidden_patterns.map { |pattern| Regexp.new(pattern) }
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -182,10 +182,18 @@ module RuboCop
         return ":\"#{value.source}\"" if value.dsym_type?
         return "\"#{value.source}\"" if value.dstr_type?
         return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
 
         "'#{value.source}'"
       end
 
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
       def except_key(node)
         key_arg = node.argument_list.first.source
         body, = extract_body_if_negated(node.body)

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -94,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -75,7 +75,7 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment = processed_source.comments.find { |c| same_line?(c, node) }
+        comment = processed_source.comment_at_line(node.first_line)
         return unless comment
 
         comment_source = comment.source

data/lib/rubocop/cop/naming/file_name.rb

@@ -203,9 +203,10 @@ module RuboCop
 
         def match_acronym?(expected, name)
           expected = expected.to_s
-          name = name.to_s
-
-          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
+          name = allowed_acronyms.reduce(name.to_s) do |result, acronym|
+            result.gsub(acronym, acronym.capitalize)
+          end
+          expected == name
         end
 
         def to_namespace(path) # rubocop:disable Metrics/AbcSize

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -91,6 +91,8 @@ module RuboCop
         end
 
         def on_new_investigation
+          return unless @flagged_terms_regex
+
           investigate_filepath if cop_config['CheckFilepaths']
           investigate_tokens
         end
@@ -144,7 +146,7 @@ module RuboCop
         def preprocess_flagged_terms
           allowed_strings = []
           flagged_term_strings = []
-          cop_config['FlaggedTerms'].each do |term, term_definition|
+          (cop_config['FlaggedTerms'] || {}).each do |term, term_definition|
             next if term_definition.nil?
 
             allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
@@ -181,7 +183,11 @@ module RuboCop
         end
 
         def set_regexes(flagged_term_strings, allowed_strings)
-          @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
+          # With no flagged terms an empty regex would match everything, so leave the
+          # regex nil and let `on_new_investigation` treat the cop as a no-op.
+          unless flagged_term_strings.empty?
+            @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
+          end
           @allowed_regex = array_to_ignorecase_regex(allowed_strings) unless allowed_strings.empty?
         end
 

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -174,6 +174,7 @@ module RuboCop
 
           method_node, method_name = find_definition(node)
           return unless method_node
+          return unless nameable_method?(method_name)
 
           body = method_node.body
           return unless body == node || body.children.last == node
@@ -209,6 +210,7 @@ module RuboCop
 
           method_node, method_name = find_definition(node)
           return false unless method_node
+          return false unless nameable_method?(method_name)
 
           defined_memoized?(method_node.body, arg.name) do |defined_ivar, return_ivar, ivar_assign|
             return false if matches?(method_name, ivar_assign)
@@ -250,6 +252,13 @@ module RuboCop
           nil
         end
 
+        # Operator and other non-word method names (e.g. `[]`, `+`, `<=>`) cannot form a
+        # valid instance variable name, so there is no matching ivar to enforce and a
+        # suggested correction like `@[]` would be invalid Ruby.
+        def nameable_method?(method_name)
+          /\A[a-zA-Z_]\w*\z/.match?(method_name.to_s.delete('!?='))
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || INITIALIZE_METHODS.include?(method_name)
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -95,11 +95,14 @@ module RuboCop
 
         def autocorrect(corrector, node, range, offending_name, preferred_name)
           corrector.replace(range, preferred_name)
-          correct_node(corrector, node.body, offending_name, preferred_name)
+          # Once the exception variable is reassigned, later references point to a
+          # different value, so stop correcting after the reassignment - both in the
+          # body and in the code following the `begin`/`rescue`.
+          return if correct_node(corrector, node.body, offending_name, preferred_name)
           return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
 
           kwbegin_node.right_siblings.each do |child_node|
-            correct_node(corrector, child_node, offending_name, preferred_name)
+            break if correct_node(corrector, child_node, offending_name, preferred_name)
           end
         end
 
@@ -113,6 +116,8 @@ module RuboCop
           end
         end
 
+        # Returns the reassignment node once the exception variable is reassigned (a truthy
+        # signal to stop correcting later references), or `nil` when no reassignment is found.
         # rubocop:disable Metrics/MethodLength
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
@@ -131,9 +136,10 @@ module RuboCop
 
             if child_node.type?(:masgn, :lvasgn)
               correct_reassignment(corrector, child_node, offending_name, preferred_name)
-              break
+              return child_node
             end
           end
+          nil
         end
         # rubocop:enable Metrics/MethodLength
 

data/lib/rubocop/cop/security/io_methods.rb

@@ -37,7 +37,7 @@ module RuboCop
           return unless (receiver = node.receiver) && receiver.source == 'IO'
 
           argument = node.first_argument
-          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+          return if argument&.str_type? && argument.value.strip.start_with?('|')
 
           add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
             corrector.replace(receiver, 'File')

data/lib/rubocop/cop/security/marshal_load.rb

@@ -25,7 +25,7 @@ module RuboCop
         # @!method marshal_load(node)
         def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}
-          !(send (const {nil? cbase} :Marshal) :dump ...))
+          !(send (const {nil? cbase} :Marshal) :dump ...) _?)
         PATTERN
 
         def on_send(node)

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

@@ -203,13 +203,23 @@ module RuboCop
         end
 
         def range_with_trailing_argument_comment(node)
-          comment = processed_source.ast_with_comments[node.last_argument].last
+          comment = trailing_argument_comment(node)
           if comment
             add_range(node.source_range, comment.source_range)
           else
             node
           end
         end
+
+        # For a single-line declaration the parser associates the trailing
+        # comment with the first argument, not `last_argument`, so look through
+        # all arguments for a comment that trails the whole node.
+        def trailing_argument_comment(node)
+          comments = node.arguments.filter_map do |argument|
+            processed_source.ast_with_comments[argument].last
+          end
+          comments.find { |comment| comment.source_range.begin_pos >= node.source_range.end_pos }
+        end
       end
     end
   end

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

@@ -113,7 +113,7 @@ module RuboCop
               return :lexical
             when :def, :defs
               return :dynamic
-            when :block
+            when :block, :numblock, :itblock
               return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic

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

@@ -71,7 +71,7 @@ module RuboCop
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
-              elsif expr.return_type? || expr.assignment?
+              elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
                 correct_other(expr, corrector)
               end
             end

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

@@ -153,7 +153,7 @@ module RuboCop
         BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding]
+          [Naming::BlockForwarding, Style::MethodDefParentheses]
         end
 
         def on_def(node)

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

@@ -40,8 +40,9 @@ module RuboCop
 
           node = innermost_braces_node(node)
           return if node.parent && brace_method?(node.parent)
+          return if compound_assignment_target?(node)
 
-          preferred = (value.zero? ? 'first' : 'last')
+          preferred = preferred_name(value)
           offense_range = find_offense_range(node)
 
           add_offense(offense_range, message: format(MSG, preferred: preferred)) do |corrector|
@@ -53,6 +54,10 @@ module RuboCop
 
         private
 
+        def preferred_name(value)
+          value.zero? ? 'first' : 'last'
+        end
+
         def preferred_value(node, value)
           value = ".#{value}" unless node.loc.dot
           value
@@ -74,6 +79,12 @@ module RuboCop
         def brace_method?(node)
           node.send_type? && (node.method?(:[]) || node.method?(:[]=))
         end
+
+        # `arr[0] += 1` etc. would autocorrect to `arr.first += 1`, which calls the
+        # nonexistent `first=`/`last=` setter and raises `NoMethodError`.
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
+        end
       end
     end
   end

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

@@ -47,7 +47,7 @@ module RuboCop
       #
       #   # bad
       #   array1.any? { |elem| array2.member?(elem) }
-      #   array1.none? { |elem| array2.member?(elem) }
+      #   array1.none? { |elem| array2.include?(elem) }
       #
       #   # good
       #   array1.intersect?(array2)
@@ -121,15 +121,15 @@ module RuboCop
             (block
               (call $_receiver ${:any? :none?})
               (args (arg _key))
-              (send $_argument :member? (lvar _key))
+              (send $_argument {:member? :include?} (lvar _key))
             )
             (numblock
               (call $_receiver ${:any? :none?}) 1
-              (send $_argument :member? (lvar :_1))
+              (send $_argument {:member? :include?} (lvar :_1))
             )
             (itblock
               (call $_receiver ${:any? :none?}) :it
-              (send $_argument :member? (lvar :it))
+              (send $_argument {:member? :include?} (lvar :it))
             )
           }
         PATTERN
@@ -145,6 +145,10 @@ module RuboCop
 
           dot = dot_node.loc.dot.source
           bang = straight?(method_name) ? '' : '!'
+          # `a&.intersection(b)&.none?` returns `nil` when `a` is `nil`, but the negated
+          # rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return if bang == '!' && dot == '&.'
+
           replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
           register_offense(node, replacement)

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

@@ -29,6 +29,9 @@ module RuboCop
         def on_send(node)
           array, element = single_element(node)
           return unless array
+          # `[*foo]` is not a single element: the splat can expand to any number of
+          # elements, so `intersect?([*foo])` is not equivalent to `include?(*foo)`.
+          return if element.splat_type?
 
           add_offense(
             node.source_range.with(begin_pos: node.loc.selector.begin_pos)

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

@@ -389,9 +389,23 @@ module RuboCop
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
-          return false unless (resbody = node.each_descendant(:resbody).first)
 
-          resbody.children.first&.array_type?
+          body = node.body
+          return false unless body
+          # `ensure` and a block-level `rescue` are illegal inside `{ }`; only a
+          # bare modifier rescue (`expr rescue expr`) can be written with braces.
+          return true if body.ensure_type?
+          return false unless body.rescue_type?
+
+          !modifier_rescue?(body)
+        end
+
+        def modifier_rescue?(rescue_node)
+          return false if rescue_node.body.nil? || rescue_node.else_branch
+          return false unless rescue_node.resbody_branches.one?
+
+          resbody = rescue_node.resbody_branches.first
+          resbody.exceptions.empty? && resbody.exception_variable.nil?
         end
 
         def braces_required_method?(method_name)