rubocop 1.88.2 → 1.90.0

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

@@ -10,6 +10,32 @@ module RuboCop
       # the developer intends to suppress Ruby's method redefinition warnings.
       # See https://bugs.ruby-lang.org/issues/13574.
       #
+      # By default the cop can only detect duplicates within a single file.
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the cop additionally consults the project-wide index and reports methods
+      # whose duplicate definition lives in another file.
+      #
+      # NOTE: The project index does not record whether a definition in another
+      # file is wrapped in a conditional, so a platform-specific redefinition in
+      # another file may still be reported. Aliasing the method to itself (see above)
+      # before redefining marks the redefinition as intentional and is respected
+      # across files. With `AllCops/ActiveSupportExtensionsEnabled: true`, Active
+      # Support's redefinition markers (`silence_redefinition_of_method` and
+      # `redefine_method`) are honored the same way.
+      #
+      # NOTE: Methods defined with `define_method` are not recorded in the project
+      # index, so a duplicate whose other definition uses `define_method` cannot
+      # be detected across files.
+      #
+      # Cross-file duplicates whose other definition lives in a file matching one
+      # of the `AllowedCrossFilePaths` patterns are not reported. This suits files
+      # that redefine application methods but are never loaded together with them,
+      # such as standalone scripts. Patterns are matched with the same glob (or
+      # regexp) semantics as `Exclude`, against the other file's path relative to
+      # the directory of the `.rubocop.yml` that configures the cop; absolute
+      # patterns are matched against the absolute path. Offenses inside such files
+      # themselves are best silenced with an ordinary per-cop `Exclude`.
+      #
       # @example
       #
       #   # bad
@@ -118,16 +144,64 @@ module RuboCop
       #     delegate :foo, to: :bar
       #   end
       #
+      #   # good - Active Support's redefinition markers signal an intentional
+      #   # redefinition of a method defined in another file
+      #   silence_redefinition_of_method :foo
+      #   def foo
+      #     1
+      #   end
+      #
+      # @example AllowedCrossFilePaths: ['script/**/*'] (default: [])
+      #   # Cross-file duplicates whose other definition lives in a file
+      #   # matching one of the patterns are not reported.
+      #
+      #   # good - assuming `AppHelper#format` is also defined in
+      #   # `script/backfill.rb`, which is never loaded with this file
+      #   class AppHelper
+      #     def format
+      #     end
+      #   end
+      #
+      # @example DelegatingMethods: ['delegate', 'expose'] (default: ['delegate'])
+      #   # A project's own `delegate`-shaped macros can be registered so the
+      #   # methods they define are recognized (with
+      #   # `AllCops/ActiveSupportExtensionsEnabled: true`).
+      #
+      #   # bad
+      #   def foo
+      #     1
+      #   end
+      #
+      #   expose :foo, to: :bar
+      #
       class DuplicateMethods < Base # rubocop:disable Metrics/ClassLength
+        include ProjectIndexHelp
+
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
-                              delegate def_delegator def_instance_delegator def_delegators
-                              def_instance_delegators].freeze
+
+        # Method names the cop registers that can be looked up in the project index:
+        # a fully qualified namespace followed by `#` (instance) or `.` (singleton)
+        # and the method name.
+        INDEXABLE_METHOD_NAME =
+          /\A(?<owner>[A-Z]\w*(?:::[A-Z]\w*)*)(?<separator>[#.])(?<name>[^#.]+)\z/.freeze
+        # No `RESTRICT_ON_SEND`: the delegating method names are configurable
+        # (`DelegatingMethods`), so `on_send` must see every call. The handler
+        # returns quickly for calls that are not method definitions, and
+        # benchmarks show no measurable cost over the previous fixed list.
 
         def initialize(config = nil, options = nil)
           super
           @definitions = {}
           @scopes = Hash.new { |hash, key| hash[key] = [] }
+          @intentionally_redefined = Set.new
+        end
+
+        def on_new_investigation
+          # The self-alias trick and Active Support's redefinition markers declare
+          # an intentional redefinition only within the file that uses them, so the
+          # tracked names do not carry over.
+          @intentionally_redefined = Set.new
+          super
         end
 
         def on_def(node)
@@ -157,7 +231,11 @@ module RuboCop
         def on_alias(node)
           name, original_name = method_alias?(node)
           return unless name && original_name
-          return if name == original_name
+
+          if name == original_name
+            track_intentional_redefinition(node, name)
+            return
+          end
           return if node.ancestors.any?(&:if_type?)
 
           found_instance_method(node, name)
@@ -168,9 +246,12 @@ module RuboCop
           (send nil? :alias_method (sym $_name) (sym $_original_name))
         PATTERN
 
-        # @!method delegate_method?(node)
-        def_node_matcher :delegate_method?, <<~PATTERN
-          (send nil? :delegate
+        # Matches the argument shape of an Active Support `delegate` call
+        # (`delegate :a, :b, to: :target`), regardless of the method name; the
+        # name is checked separately against `DelegatingMethods`.
+        # @!method delegate_args(node)
+        def_node_matcher :delegate_args, <<~PATTERN
+          (send nil? _
             ({sym str} $_)+
             (hash <(pair (sym :to) {sym str}) ...>)
           )
@@ -194,6 +275,15 @@ module RuboCop
           )
         PATTERN
 
+        # Matches Active Support's markers of an intentional method redefinition:
+        # `silence_redefinition_of_method :name` suppresses Ruby's redefinition
+        # warning for a subsequent definition of `name`, and
+        # `redefine_method(:name) { ... }` both silences the warning and redefines.
+        # @!method active_support_redefinition_marker(node)
+        def_node_matcher :active_support_redefinition_marker, <<~PATTERN
+          (send nil? {:silence_redefinition_of_method :redefine_method} ({sym str} $_) ...)
+        PATTERN
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
@@ -204,17 +294,27 @@ module RuboCop
             ...)
         PATTERN
 
+        # @!method class_new_block?(node)
+        def_node_matcher :class_new_block?, <<~PATTERN
+          (block
+            (send (const _ :Class) :new ...)
+            ...)
+        PATTERN
+
         def on_send(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           name, original_name = alias_method?(node)
 
           if name && original_name
-            return if name == original_name
+            if name == original_name
+              track_intentional_redefinition(node, name)
+              return
+            end
             return if inside_condition?(node)
 
             found_instance_method(node, name)
           elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
-          elsif active_support_extensions_enabled? && (names = delegate_method?(node))
+          elsif delegating_method?(node) && (names = delegate_args(node))
             return if inside_condition?(node)
 
             on_delegate(node, names)
@@ -226,6 +326,12 @@ module RuboCop
             return if inside_condition?(node)
 
             names.each { |name| found_instance_method(node, name) }
+          elsif (name = active_support_redefinition_marker(node))
+            # `redefine_method` takes a block; scope resolution must start from the
+            # block node, since `parent_module_name` cannot see through a block
+            # ancestor that is not a module constructor.
+            track_intentional_redefinition(node.block_node || node, name) if
+              active_support_extensions_enabled?
           end
         end
 
@@ -257,6 +363,19 @@ module RuboCop
                       current: source_location(node))
         end
 
+        # Recognizing a delegating call as a method definition is Active
+        # Support behavior, so it stays gated on `ActiveSupportExtensionsEnabled`
+        # as it was when only `delegate` was supported. `DelegatingMethods` lets
+        # a project register its own `delegate`-shaped macros.
+        def delegating_method?(node)
+          active_support_extensions_enabled? &&
+            delegating_methods.include?(node.method_name.to_s)
+        end
+
+        def delegating_methods
+          cop_config.fetch('DelegatingMethods', ['delegate'])
+        end
+
         def on_delegate(node, method_names)
           name_prefix = delegate_prefix(node)
 
@@ -318,13 +437,27 @@ module RuboCop
           parent = anon_block.parent
           return unless parent&.type?(:any_block, :begin, :call, :casgn, :any_def)
 
-          if (receiver = named_receiver(parent))
+          if (receiver = scope_receiver(parent, anon_block))
             "#{receiver.source}.#{parent.method_name}"
           elsif !parent.begin_type? || parent.parent&.any_block_type?
-            source_location(anon_block)
+            anon_block_identity(anon_block)
           end
         end
 
+        # When a Class.new block is passed as an argument to a named-receiver
+        # method call (e.g. T.cast(Class.new(Base) do ... end, ...)), the
+        # receiver-based scope id (e.g. "T.cast") is the same for every call,
+        # causing false positives for methods defined in distinct anonymous
+        # classes. Return nil so the block falls through to the unique
+        # source-location-based scope id.
+        # Module.new blocks are excluded because they may be intentionally
+        # mixed into the same target via prepend/include/extend.
+        def scope_receiver(parent, anon_block)
+          return if class_new_block?(anon_block) && parent.call_type?
+
+          named_receiver(parent)
+        end
+
         def named_receiver(node)
           receiver = node.receiver
           receiver unless class_or_module_new_block?(receiver)
@@ -340,27 +473,57 @@ module RuboCop
           found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
         end
 
-        # rubocop:disable Metrics/AbcSize
         def found_method(node, method_name, scope_id: nil)
           key = method_key(node, method_name)
           key = "#{key}@#{scope_id}" if scope_id
           scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
-            if scope && !@scopes[scope].include?(key)
-              @definitions[key] = node
-              @scopes[scope] << key
-              return
-            end
-
-            message = message_for_dup(node, method_name, key)
-
-            add_offense(location(node), message: message)
+            found_redefinition(node, method_name, key, scope)
           else
             @definitions[key] = node
+            check_cross_file_duplicate(node, method_name) if scope_id.nil? && scope.nil?
           end
         end
-        # rubocop:enable Metrics/AbcSize
+
+        def found_redefinition(node, method_name, key, scope)
+          if scope && !@scopes[scope].include?(key)
+            @definitions[key] = node
+            @scopes[scope] << key
+          elsif intentional_cross_file_redefinition?(node, method_name, key) ||
+                allowed_cross_file_redefinition?(node, key)
+            @definitions[key] = node
+          else
+            add_offense(location(node), message: message_for_dup(node, method_name, key))
+          end
+        end
+
+        # `AllowedCrossFilePaths` also covers duplicates detected without the index,
+        # when the cop instance carries definitions over from an earlier file of the
+        # same run.
+        def allowed_cross_file_redefinition?(node, key)
+          other_path = @definitions[key].source_range.source_buffer.name
+          return false if other_path == node.source_range.source_buffer.name
+
+          allowed_cross_file_path?(other_path)
+        end
+
+        # The self-alias trick (`alias foo foo` or `alias_method :foo, :foo` right before
+        # a `def`) suppresses Ruby's method redefinition warning, signaling an intentional
+        # redefinition of a method defined in another file. Active Support's redefinition
+        # markers (tracked when `ActiveSupportExtensionsEnabled` is on) signal the same.
+        def intentional_cross_file_redefinition?(node, method_name, key)
+          @intentionally_redefined.include?(method_name) &&
+            @definitions[key].source_range.source_buffer.name !=
+              node.source_range.source_buffer.name
+        end
+
+        def track_intentional_redefinition(node, name)
+          scope = node.parent_module_name
+          return unless scope
+
+          @intentionally_redefined << "#{humanize_scope(scope)}#{name}"
+        end
 
         def method_key(node, method_name)
           if (ancestor_def = node.each_ancestor(:any_def).first)
@@ -439,6 +602,121 @@ module RuboCop
           path = smart_path(range.source_buffer.name)
           "#{path}:#{range.line}"
         end
+
+        def check_cross_file_duplicate(node, method_name)
+          return unless project_index
+          return if @intentionally_redefined.include?(method_name)
+          return if node.each_ancestor(:any_def).any?
+          return unless (prior = cross_file_prior_definition(method_name))
+
+          message = format(MSG, method: method_name,
+                                defined: index_source_location(prior),
+                                current: source_location(node))
+          add_offense(location(node), message: message)
+        end
+
+        def cross_file_prior_definition(method_name)
+          return unless (match = INDEXABLE_METHOD_NAME.match(method_name))
+
+          definitions = definitions_in_other_files(
+            indexed_definitions(match[:owner], match[:separator], match[:name])
+          ).reject { |definition| allowed_cross_file_path?(definition.location.to_file_path) }
+          return if definitions.empty? || cross_file_self_alias_trick?(definitions)
+          return if cross_file_redefinition_marker?(definitions, match[:name])
+
+          first_indexed_definition(definitions)
+        end
+
+        # Cross-file duplicates whose other definition site matches one of the
+        # `AllowedCrossFilePaths` patterns are skipped (e.g. standalone scripts that
+        # are never loaded together with the code they redefine). Patterns are
+        # matched like `Exclude` patterns, against the path relative to the
+        # directory of the config file that configures the cop; absolute patterns
+        # are matched against the absolute path.
+        def allowed_cross_file_path?(path)
+          patterns = cop_config.fetch('AllowedCrossFilePaths', [])
+          return false if patterns.empty?
+
+          relative = config.path_relative_to_config(path)
+          patterns.any? { |pattern| match_path?(pattern, relative) || match_path?(pattern, path) }
+        end
+
+        def indexed_definitions(owner, separator, name)
+          namespace = separator == '.' ? "#{owner}::<#{owner.split('::').last}>" : owner
+
+          if name.match?(/\A\w+=\z/)
+            # Rubydex indexes `attr_writer :foo` under `foo` rather than `foo=`, so
+            # writer definitions come from both the `foo=` and the `foo` declarations.
+            indexed_declaration_definitions(namespace, name) +
+              indexed_declaration_definitions(namespace, name.delete_suffix('='))
+              .select { |definition| writer_attr_definition?(definition) }
+          else
+            indexed_declaration_definitions(namespace, name).grep_v(Rubydex::AttrWriterDefinition)
+          end
+        end
+
+        def indexed_declaration_definitions(namespace, name)
+          project_index["#{namespace}##{name}()"]&.definitions.to_a
+        end
+
+        def writer_attr_definition?(definition)
+          definition.is_a?(Rubydex::AttrWriterDefinition) ||
+            definition.is_a?(Rubydex::AttrAccessorDefinition)
+        end
+
+        # An alias of the method alongside one of its definitions in another file may be
+        # the self-alias trick marking an intentional redefinition there, so no offense
+        # is registered. A genuine `alias` duplicate is still reported when the alias
+        # itself is inspected.
+        def cross_file_self_alias_trick?(definitions)
+          aliases, others = definitions.partition do |definition|
+            definition.is_a?(Rubydex::MethodAliasDefinition)
+          end
+          alias_paths = aliases.map { |definition| definition.location.to_file_path }
+
+          others.any? { |definition| alias_paths.include?(definition.location.to_file_path) }
+        end
+
+        # An Active Support redefinition marker alongside one of the definitions in
+        # another file marks the redefinition there as intentional, like the
+        # self-alias trick. The index does not record the marker's method-name
+        # argument, so the other file's source is searched for a marker naming
+        # the method.
+        def cross_file_redefinition_marker?(definitions, name)
+          return false unless active_support_extensions_enabled?
+
+          definitions.map { |definition| definition.location.to_file_path }.uniq.any? do |path|
+            redefinition_marker_in_file?(path, name)
+          end
+        end
+
+        def redefinition_marker_in_file?(path, name)
+          return false unless File.readable?(path)
+
+          escaped = Regexp.escape(name)
+          marker = /\b(?:silence_redefinition_of_method|redefine_method)\s*\(?\s*
+                    (?::#{escaped}|(["'])#{escaped}\1)(?![\w=!?])/x
+          File.read(path).scrub.match?(marker)
+        end
+
+        def first_indexed_definition(definitions)
+          definitions.find { |definition| !definition.is_a?(Rubydex::MethodAliasDefinition) }
+        end
+
+        def index_source_location(definition)
+          location = definition.location
+          "#{smart_path(location.to_file_path)}:#{location.to_display.start_line}"
+        end
+
+        # Internal identity for an anonymous block, used as a scope key.
+        # Includes the source range's begin position to distinguish blocks
+        # that share the same line (e.g. two Class.new calls separated by `;`).
+        # The user-facing offense message still uses `source_location`, which
+        # shows only `path:line`.
+        def anon_block_identity(anon_block)
+          range = anon_block.source_range
+          "#{smart_path(range.source_buffer.name)}:#{range.line}:#{range.begin_pos}"
+        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module RuboCop
         FOR_METHOD = ' Or, if they were intended to be separate method ' \
                      'arguments, separate them with a comma.'
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
         def on_dstr(node)
           each_bad_cons(node) do |lhs_node, rhs_node|
             range = lhs_node.source_range.join(rhs_node.source_range)
@@ -52,7 +52,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         private
 

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

@@ -80,7 +80,7 @@ module RuboCop
                       alternative: alternative)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block)
           node.each_child_node do |child|
             case child.type
@@ -97,7 +97,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def access_modifier?(node)
           node.bare_access_modifier? && !node.method?(:module_function)

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

@@ -12,6 +12,11 @@ module RuboCop
       #   exception class handle `StandardError` and its subclasses,
       #   but not `Exception` and its subclasses.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, indirect inheritance is also detected: a class whose parent
+      # (defined anywhere in the project) ultimately inherits from `Exception`
+      # is reported, without autocorrection.
+      #
       # @example EnforcedStyle: standard_error (default)
       #   # bad
       #
@@ -39,9 +44,11 @@ module RuboCop
       #   C = Class.new(RuntimeError)
       class InheritException < Base
         include ConfigurableEnforcedStyle
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Inherit from `%<prefer>s` instead of `Exception`.'
+        INDIRECT_MSG = 'Inherit from `%<prefer>s` instead of `Exception` (inherited via `%<via>s`).'
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
@@ -57,13 +64,20 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class && exception_class?(node.parent_class)
-          return if inherit_exception_class_with_omitted_namespace?(node)
-
-          message = message(node.parent_class)
-
-          add_offense(node.parent_class, message: message) do |corrector|
-            corrector.replace(node.parent_class, preferred_base_class)
+          parent_class = node.parent_class
+          return unless parent_class
+
+          if exception_class?(parent_class)
+            return if inherit_exception_class_with_omitted_namespace?(node)
+
+            add_offense(parent_class, message: message(parent_class)) do |corrector|
+              corrector.replace(parent_class, preferred_base_class)
+            end
+          elsif (via = inherits_exception_via(parent_class))
+            # No autocorrection: the `Exception` inheritance lives at another
+            # class' definition site, possibly in another file.
+            message = format(INDIRECT_MSG, prefer: preferred_base_class, via: via)
+            add_offense(parent_class, message: message)
           end
         end
 
@@ -88,6 +102,38 @@ module RuboCop
           class_node.const_name == 'Exception'
         end
 
+        # When `AllCops/UseProjectIndex` is enabled, indirect inheritance is
+        # detected by walking the parent's indexed ancestry: `Exception` itself
+        # is not indexed, so a chain ending in it shows up as an ancestor whose
+        # superclass reference is unresolved and literally named `Exception`.
+        # Returns the name of that ancestor, or `nil`.
+        def inherits_exception_via(parent_class)
+          return nil unless project_index && parent_class.const_type?
+
+          declaration = resolve_constant_in_index(parent_class)
+          return nil unless declaration.is_a?(Rubydex::Class)
+
+          exception_ancestor(declaration)&.name
+        rescue StandardError
+          nil
+        end
+
+        def exception_ancestor(declaration)
+          declaration.ancestors.find do |ancestor|
+            ancestor.is_a?(Rubydex::Class) && exception_superclass_reference?(ancestor)
+          end
+        end
+
+        def exception_superclass_reference?(ancestor)
+          ancestor.definitions.any? do |definition|
+            next false unless definition.is_a?(Rubydex::ClassDefinition)
+
+            superclass = definition.superclass
+            superclass.is_a?(Rubydex::UnresolvedConstantReference) &&
+              superclass.name.delete_prefix('::') == 'Exception'
+          end
+        end
+
         def inherit_exception_class_with_omitted_namespace?(class_node)
           return false if class_node.parent_class.namespace&.cbase_type?
 

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

@@ -41,7 +41,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
@@ -51,7 +51,6 @@ module RuboCop
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')

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

@@ -88,7 +88,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_while_post(node)
           return if node.condition.source == 'true'
 
@@ -102,7 +102,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_until(node)
           return if node.condition.source == 'false'
@@ -118,7 +117,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_until_post(node)
           return if node.condition.source == 'false'
 
@@ -132,7 +131,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
           if (cond = case_node.condition)
@@ -250,10 +248,15 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def correct_if_node(node, cond)
           result = condition_evaluation?(node, cond)
 
+          # When the branch that survives the literal condition is missing,
+          # there is no meaningful correction, so no offense is registered.
+          surviving_branch = result ? node.if_branch : node.else_branch
+          return if surviving_branch.nil? && (node.elsif? || node.else?)
+
           new_node = if node.elsif? && result
                        "else\n  #{range_with_comments(node.if_branch).source}"
                      elsif node.elsif? && !result
@@ -276,7 +279,6 @@ module RuboCop
             ignore_node(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -24,7 +24,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -50,7 +50,6 @@ module RuboCop
             corrector.replace(final_node.parent, replacement)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -74,7 +73,7 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -95,7 +94,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def handle_special_regexp_chars(begin_node, value)
           parent_node = begin_node.parent
@@ -155,7 +153,7 @@ module RuboCop
           "{#{hash_string}}"
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
         def autocorrected_value_in_hash(node)
           case node.type
           when :int
@@ -163,7 +161,7 @@ module RuboCop
           when :float
             node.children.last.to_f.to_s
           when :str
-            "\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+            escape_string_content(node.value.inspect)
           when :sym
             autocorrected_value_in_hash_for_symbol(node)
           when :array
@@ -174,7 +172,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)