rubocop 1.87.0 → 1.88.1

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

@@ -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)

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

@@ -96,13 +96,25 @@ module RuboCop
         end
 
         def const_replacement(lhs, rhs)
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
         end
 
         def send_replacement(lhs, rhs)
           return unless self_class?(lhs)
 
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
+        end
+
+        # `Array === a + b` must become `(a + b).is_a?(Array)`, not
+        # `a + b.is_a?(Array)` (which parses as `a + (b.is_a?(Array))`).
+        def parenthesize_if_needed(node)
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if node.type?(:and, :or, :if, :range) || node.assignment?
+
+          node.send_type? && (node.operator_method? || node.unary_operation?)
         end
       end
     end

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

@@ -90,25 +90,33 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if class_name_method?(node.children.first.method_name)
-            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
-              return receiver.source
-            end
+          unless class_name_method?(node.children.first.method_name)
+            # `var.class == 'Foo'` compares a `Class` to a `String` (always false) and
+            # has no valid `instance_of?` rewrite, so don't suggest one.
+            return if class_node.str_type?
 
-            if class_node.str_type?
-              value = trim_string_quotes(class_node)
-              value.prepend('::') if require_cbase?(class_node)
-              return value
-            elsif unable_to_determine_type?(class_node)
-              # When a variable or return value of a method is used, it returns nil
-              # because the type is not known and cannot be suggested.
-              return
-            end
+            return class_node.source
+          end
+
+          if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+            return receiver.source
           end
 
+          return string_class_name(class_node) if class_node.str_type?
+          # When a variable or return value of a method is used, the type is not known
+          # and cannot be suggested.
+          return if unable_to_determine_type?(class_node)
+
           class_node.source
         end
 
+        def string_class_name(class_node)
+          value = trim_string_quotes(class_node)
+          # Avoid `::::Foo` when the name is already fully qualified.
+          value.prepend('::') if require_cbase?(class_node) && !value.start_with?('::')
+          value
+        end
+
         def class_name_method?(method_name)
           CLASS_NAME_METHODS.include?(method_name)
         end

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

@@ -140,15 +140,21 @@ module RuboCop
 
         def extract_def_from_sclass(def_node, sclass_node)
           range = source_range_with_comment(def_node)
-          source = range.source.sub!(
-            "def #{def_node.method_name}",
-            "def self.#{def_node.method_name}"
-          )
-
+          source = prefix_def_with_self(range, def_node)
           source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
           [range, source.chomp]
         end
 
+        # Splice in `self.` at the actual `def` keyword rather than substituting the
+        # first textual `def <name>`, which may appear inside a preceding comment.
+        def prefix_def_with_self(range, def_node)
+          keyword_offset = def_node.loc.keyword.begin_pos - range.begin_pos
+          name_end_offset = def_node.loc.name.end_pos - range.begin_pos
+          source = range.source.dup
+          source[keyword_offset...name_end_offset] = "def self.#{def_node.method_name}"
+          source
+        end
+
         def indentation_diff(node1, node2)
           node1.loc.column - node2.loc.column
         end

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

@@ -24,10 +24,9 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
-        # @!method java_type_node?(node)
-        def_node_matcher :java_type_node?, <<~PATTERN
-          (send
-            (const nil? :Java) _)
+        # @!method java_root?(node)
+        def_node_matcher :java_root?, <<~PATTERN
+          (const nil? :Java)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -37,11 +36,19 @@ module RuboCop
         def on_send(node)
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
+          # ignore Java interop code like `Java::int` or `Java::com::method`
+          return if java_interop?(node)
 
           add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+
+        private
+
+        def java_interop?(node)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver.respond_to?(:receiver) && receiver.receiver
+          java_root?(receiver)
+        end
       end
     end
   end

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

@@ -85,8 +85,13 @@ module RuboCop
         def on_for(node)
           return unless node.parent&.begin_type?
           return unless same_collection_looping_for?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            # Combining loops with different iteration variables would leave the second
+            # body referencing an undefined variable, so only autocorrect when they match.
+            next unless node.variable == node.left_sibling.variable
+
             combine_with_left_sibling(corrector, node)
           end
         end

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

@@ -90,7 +90,7 @@ module RuboCop
             max = if_body.source
           end
 
-          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+          prefer = "#{parenthesize_if_needed(else_body)}.clamp(#{min}, #{max})"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             autocorrect(corrector, node, prefer)
@@ -119,6 +119,17 @@ module RuboCop
 
           (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
         end
+
+        # `a + b` must become `(a + b).clamp(low, high)`, not `a + b.clamp(low, high)`
+        # (which parses as `a + (b.clamp(low, high))`).
+        def parenthesize_if_needed(node)
+          if node.type?(:and, :or, :if, :range) || node.assignment? ||
+             (node.send_type? && (node.operator_method? || node.unary_operation?))
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
       end
     end
   end

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

@@ -55,6 +55,10 @@ module RuboCop
               next unless prefer
 
               corrector.replace(offense, prefer)
+            elsif node.arguments.any? { |argument| argument.children.empty? }
+              # In-place bracket removal would leave dangling commas (e.g.
+              # `concat([], [b])` -> `push(, b)`), so rebuild the call instead.
+              corrector.replace(offense, preferred_method(node))
             else
               corrector.replace(node.loc.selector, 'push')
               node.arguments.each do |argument|
@@ -75,7 +79,7 @@ module RuboCop
 
         def preferred_method(node)
           new_arguments =
-            node.arguments.map do |arg|
+            node.arguments.flat_map do |arg|
               if arg.percent_literal?
                 arg.children.map { |child| child.value.inspect }
               else

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

@@ -283,7 +283,10 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
 
-          return unless else_branch
+          # Use the node accessor rather than the raw destructured branch: for
+          # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
+          # else slot, but `else_branch` correctly reports there is no `else` clause.
+          return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
@@ -657,6 +660,8 @@ module RuboCop
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
+            return if same_line?(parent_keyword, condition)
+
             corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end

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

@@ -89,7 +89,10 @@ module RuboCop
 
             arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
             constant_values = arguments.map do |argument|
-              argument.value.to_sym if argument.respond_to?(:value)
+              # `respond_to?(:value)` is too broad: `int`/`float` nodes respond to it
+              # but their value is a `Numeric`, which has no `to_sym` (e.g.
+              # `private_constant 42`). Only symbol/string arguments are real names.
+              argument.value.to_sym if argument.type?(:sym, :str)
             end
 
             constant_values.include?(node.name)

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))

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method historic_date?(node)
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+          (call _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (call _ :to_datetime)
+          (call !nil? :to_datetime)
         PATTERN
 
         def on_send(node)

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

@@ -79,6 +79,11 @@ module RuboCop
             corrector.replace(range, replacement)
 
             comments_in_range(node).reverse_each do |comment|
+              # Only relocate comments that the replacement destroys. A trailing
+              # comment after the chain survives in place, so moving it would
+              # duplicate it (and splitting the line drops the indentation).
+              next if comment.source_range.begin_pos >= range.end_pos
+
               corrector.insert_before(node, "#{comment.source}\n")
             end
           end

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

@@ -35,6 +35,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          # A trailing block (e.g. `Dir.each_child(path).none? { ... }`) changes
+          # the meaning and is not equivalent to `Dir.empty?`.
+          return if node.block_literal?
+
           offensive?(node) do |const_node, arg_node|
             replacement = "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})"
             add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|

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

@@ -40,7 +40,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use empty `case` condition, instead use an `if` expression.'
-        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend].freeze
+        NOT_SUPPORTED_PARENT_TYPES = %i[return break next send csend yield super].freeze
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_case(case_node)
@@ -90,7 +90,17 @@ module RuboCop
             range = range_between(conditions.first.source_range.begin_pos,
                                   conditions.last.source_range.end_pos)
 
-            corrector.replace(range, conditions.map(&:source).join(' || '))
+            corrector.replace(range, conditions.map { |c| parenthesize_condition(c) }.join(' || '))
+          end
+        end
+
+        # A condition that binds looser than `||` (e.g. a ternary, range, or
+        # assignment) must be parenthesized so the joined `||` keeps its meaning.
+        def parenthesize_condition(condition)
+          if condition.assignment? || condition.type?(:if, :and, :or, :range)
+            "(#{condition.source})"
+          else
+            condition.source
           end
         end
 

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

@@ -101,12 +101,19 @@ module RuboCop
 
         def autocorrect_class_new(corrector, node, class_new_node)
           indent = ' ' * node.loc.column
-          class_name = node.name
+          class_name = constant_name(node)
           parent_class_name = class_new_node.first_argument.source
 
           corrector.replace(node, "class #{class_name} < #{parent_class_name}\n#{indent}end")
         end
 
+        # Preserve any namespace on the assigned constant (e.g. `Foo::Bar`),
+        # which `node.name` drops.
+        def constant_name(node)
+          namespace = node.namespace
+          namespace ? "#{namespace.source}::#{node.name}" : node.name
+        end
+
         def autocorrect_class_definition(corrector, node)
           class_name = node.identifier.source
           parent_class_name = node.parent_class.source

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

@@ -42,6 +42,10 @@ module RuboCop
         MSG = 'Use an empty string literal instead of heredoc.'
 
         def on_heredoc(node)
+          # A backtick heredoc (`<<~`CMD``) executes a command, so it cannot be
+          # replaced with an empty string literal.
+          return if node.xstr_type?
+
           heredoc_body = node.loc.heredoc_body
 
           return unless heredoc_body.source.empty?

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

@@ -44,13 +44,18 @@ module RuboCop
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'
 
         # @!method array_with_block(node)
-        def_node_matcher :array_with_block, '(block (send (const {nil? cbase} :Array) :new) args _)'
+        def_node_matcher :array_with_block, <<~PATTERN
+          {
+            (block (send (const {nil? cbase} :Array) :new) args _)
+            ({numblock itblock} (send (const {nil? cbase} :Array) :new) ...)
+          }
+        PATTERN
 
         # @!method hash_with_block(node)
         def_node_matcher :hash_with_block, <<~PATTERN
           {
             (block (send (const {nil? cbase} :Hash) :new) args _)
-            (numblock (send (const {nil? cbase} :Hash) :new) ...)
+            ({numblock itblock} (send (const {nil? cbase} :Hash) :new) ...)
           }
         PATTERN
 

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

@@ -45,36 +45,46 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
-              if empty_if_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
-              end
-
-              if empty_else_outcome?(child_node)
-                ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
-              end
+              trailing_conditional_correction(child_node)
             elsif style == :ternary
-              next unless child_node.modifier_form?
-
-              ternary_component = if child_node.unless?
-                                    "'' : #{child_node.if_branch.source}"
-                                  else
-                                    "#{child_node.if_branch.source} : ''"
-                                  end
-
-              add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
-                corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
-              end
+              ternary_correction(node, child_node)
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 
+        def trailing_conditional_correction(child_node)
+          # A modifier `if`/`unless` is already a trailing conditional and has
+          # no `else` branch, so the ternary-to-trailing rewrite does not apply.
+          return if child_node.modifier_form?
+
+          if empty_if_outcome?(child_node)
+            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+          end
+
+          return unless empty_else_outcome?(child_node)
+
+          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+        end
+
+        def ternary_correction(node, child_node)
+          return unless child_node.modifier_form?
+
+          ternary_component = if child_node.unless?
+                                "'' : #{child_node.if_branch.source}"
+                              else
+                                "#{child_node.if_branch.source} : ''"
+                              end
+
+          add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
+            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+          end
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end

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

@@ -45,6 +45,10 @@ module RuboCop
         def on_send(node)
           return unless env_home?(node)
           return if node.arguments.count == 2 && !node.arguments[1].nil_type?
+          # `ENV.fetch('HOME') { default }` supplies a fallback, just like
+          # `ENV.fetch('HOME', default)`. `Dir.home` ignores the block, so
+          # converting would silently drop it.
+          return if node.block_node
 
           add_offense(node) do |corrector|
             corrector.replace(node, 'Dir.home')

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

@@ -34,7 +34,7 @@ module RuboCop
           even_odd_candidate?(node) do |base_number, method, arg|
             replacement_method = replacement_method(arg, method)
             add_offense(node, message: format(MSG, method: replacement_method)) do |corrector|
-              correction = "#{base_number.source}.#{replacement_method}?"
+              correction = "#{receiver_source(base_number)}.#{replacement_method}?"
               corrector.replace(node, correction)
             end
           end
@@ -42,6 +42,16 @@ module RuboCop
 
         private
 
+        def receiver_source(node)
+          # A binary or unary operator receiver (e.g. `a * b`, `-a`) binds looser
+          # than the appended method call, so it must be wrapped in parentheses.
+          if node.send_type? && node.operator_method? && !node.method?(:[])
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
+
         def replacement_method(arg, method)
           case arg
           when 0

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

@@ -43,7 +43,8 @@ module RuboCop
           return unless (parsed_regexp = parse_regexp(regexp))
           return unless exact_match_pattern?(parsed_regexp)
 
-          prefer = "#{receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+          string = escape_single_quotes(parsed_regexp[1].text)
+          prefer = "#{receiver.source} #{new_method(node)} '#{string}'"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             corrector.replace(node, prefer)
@@ -53,6 +54,12 @@ module RuboCop
 
         private
 
+        # Escape characters that are special inside a single-quoted string so the
+        # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby.
+        def escape_single_quotes(text)
+          text.gsub(/['\\]/) { |char| "\\#{char}" }
+        end
+
         def exact_match_pattern?(parsed_regexp)
           tokens = parsed_regexp.map(&:token)
           return false unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos