rubocop 1.88.0 → 1.88.2

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

@@ -75,9 +75,10 @@ module RuboCop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         def on_send(node)
+          return unless debugger_method?(node) || debugger_require?(node)
           return if assumed_usage_context?(node)
 
-          add_offense(node) if debugger_method?(node) || debugger_require?(node)
+          add_offense(node)
         end
 
         private
@@ -101,9 +102,20 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
+          return false unless debugger_method_names.include?(send_node.method_name)
+
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        # The last segment of each configured debugger method, used to cheaply
+        # rule out the vast majority of `send` nodes before building the
+        # chained method name.
+        def debugger_method_names
+          @debugger_method_names ||= debugger_methods.to_set do |method|
+            method.to_s.split('.').last&.to_sym
+          end
+        end
+
         def debugger_require?(send_node)
           return false unless send_node.method?(:require) && send_node.arguments.one?
           return false unless (argument = send_node.first_argument).str_type?

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

@@ -15,6 +15,13 @@ module RuboCop
       # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
       # a numeric operation.
       #
+      # @safety
+      #   This cop is unsafe because the autocorrection drops the operands, which
+      #   discards any side effects of evaluating them and can change behavior when
+      #   the result is not actually constant. For example, `x / x` raises
+      #   `ZeroDivisionError` when `x` is `0`, and returns `Float::NAN` (not `1`)
+      #   when `x` is `0.0`; replacing it with `1` silences that.
+      #
       # @example
       #
       #   # bad

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

@@ -109,9 +109,11 @@ module RuboCop
           when :optarg
             send_arg.source == def_arg_name.to_s
           when :kwoptarg, :kwarg
-            send_arg.hash_type? &&
+            keyword_hash_argument?(send_arg) &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
+            return false unless keyword_hash_argument?(send_arg)
+
             send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
               child.source == def_arg.source
             end
@@ -120,6 +122,10 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def keyword_hash_argument?(send_arg)
+          send_arg.hash_type? && !send_arg.braces?
+        end
       end
     end
   end

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

@@ -36,9 +36,16 @@ module RuboCop
             # The following used `*_args` because `to_json(*args)` has
             # an offense of `Lint/UnusedMethodArgument` cop if `*args`
             # is not used.
-            corrector.insert_after(node.loc.name, '(*_args)')
+            if (opening_parenthesis = node.each_child_node(:args).first.loc.begin)
+              # Explicit empty parentheses (`def to_json()`) are already present,
+              # so insert the argument inside them to avoid producing `to_json(*_args)()`.
+              corrector.insert_after(opening_parenthesis, '*_args')
+            else
+              corrector.insert_after(node.loc.name, '(*_args)')
+            end
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -44,9 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           RuboCop::Util.silence_warnings do
-            node.parsed_tree&.each_expression do |expr|
-              detect_offenses(node, expr)
-            end
+            detect_offenses_in_tree(node, node.parsed_tree)
           end
         end
 
@@ -55,19 +53,43 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            parse_regexp(text.value)&.each_expression do |expr|
-              detect_offenses(text, expr)
-            end
+            detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
-        def detect_offenses(node, expr)
-          return unless expr.type?(:literal)
+        # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses
+        # `[^]` / `[]` as an empty set and reports the closing `]` as a separate literal.
+        # Ruby treats that `]` as the end of the class, not as an unescaped bracket,
+        # so the first `]` following an empty set must be skipped.
+        def detect_offenses_in_tree(node, tree)
+          return unless tree
+
+          skip_class_closer = false
+          tree.each_expression do |expr|
+            if empty_character_set?(expr)
+              skip_class_closer = true
+            elsif expr.type?(:literal)
+              skip_class_closer = detect_offenses(node, expr, skip_class_closer)
+            end
+          end
+        end
+
+        def empty_character_set?(expr)
+          expr.type?(:set) && expr.expressions.empty?
+        end
 
+        def detect_offenses(node, expr, skip_class_closer)
           expr.text.scan(/(?<!\\)\]/) do
             pos = Regexp.last_match.begin(0)
+
+            # The first `]` following an empty `[^]` / `[]` set closes the character class.
+            if skip_class_closer
+              skip_class_closer = false
+              next
+            end
+
             # If the unescaped bracket is the first character of the regexp, Ruby does not warn.
             # `pos` is relative to the sub-expression, so add its start offset (`expr.ts`).
             next if (expr.ts + pos).zero?
@@ -78,6 +100,8 @@ module RuboCop
               corrector.replace(location, '\]')
             end
           end
+
+          skip_class_closer
         end
 
         def range_at_index(node, index, offset)

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

@@ -52,10 +52,15 @@ module RuboCop
         def on_begin(node)
           expressions = *node
 
-          expressions.each_cons(2) do |expression1, expression2|
-            next unless flow_expression?(expression1)
-
-            add_offense(expression2)
+          # Once a flow-of-control statement is reached, every following statement
+          # in the block is unreachable, not just the one immediately after it.
+          flow_reached = false
+          expressions.each_with_index do |expression, index|
+            if flow_reached
+              add_offense(expression)
+            elsif index < expressions.size - 1 && flow_expression?(expression)
+              flow_reached = true
+            end
           end
         end
 

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/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/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/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_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

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

@@ -96,7 +96,7 @@ module RuboCop
 
         # @!method grep_v_with_nil?(node)
         def_node_matcher :grep_v_with_nil?, <<~PATTERN
-          (send _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
+          (call _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
         PATTERN
 
         def on_send(node)

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

@@ -61,6 +61,10 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
+            # Convert a brace block to `do`, so the class's own `end` closes it
+            # once the closing delimiter is removed; otherwise a dangling `{` is
+            # left behind, producing invalid Ruby.
+            corrector.replace(parent.loc.begin, 'do') if parent.braces?
             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))