rubocop 1.90.0 → 1.91.0

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

@@ -106,7 +106,7 @@ module RuboCop
           when :or
             find_target(node.lhs)
           when :match_with_lvasgn
-            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+            lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
             if lhs.regexp_type?
               rhs
             elsif rhs.regexp_type?
@@ -171,7 +171,7 @@ module RuboCop
               return collect_conditions(node.lhs, target, conditions) &&
                      collect_conditions(node.rhs, target, conditions)
             when :match_with_lvasgn
-              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+              lhs, rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
               condition_from_binary_op(lhs, rhs, target)
             when :send
               condition_from_send_node(node, target)
@@ -258,7 +258,7 @@ module RuboCop
         def regexp_with_working_captures?(node)
           case node.type
           when :match_with_lvasgn
-            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring
+            lhs, _rhs = *node # rubocop:disable InternalAffairs/NodeDestructuring -- `match_with_lvasgn` has no named operand accessors
             node.loc.selector.source == '=~' && regexp_with_named_captures?(lhs)
           when :send
             node.method?(:match) &&

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

@@ -82,12 +82,16 @@ module RuboCop
           end
         end
 
-        # rubocop:disable-next Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def visibility_declaration?(node)
           node.parent.each_child_node(:send).any? do |child|
             next false unless (arguments = visibility_declaration_for(child))
 
-            arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
+            if (splat = arguments.first)&.splat_type?
+              next true unless splat.children.first.array_type?
+
+              arguments = splat.children.first.children
+            end
             constant_values = arguments.map do |argument|
               # `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.

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

@@ -10,6 +10,10 @@ module RuboCop
       #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
+      #   It is also unsafe because constants that the class body resolves through its
+      #   ancestors (e.g. one provided by an included module) fall out of scope inside
+      #   the block.
+      #
       # @example
       #   # bad
       #   class Person < Data.define(:first_name, :last_name)
@@ -42,6 +46,7 @@ module RuboCop
 
         def on_class(node)
           return unless data_define?(node.parent_class)
+          return if defines_constants?(node.body)
 
           add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
@@ -59,6 +64,15 @@ module RuboCop
 
         private
 
+        # Constants, including nested classes and modules, are scoped to the class when they
+        # are defined in a class body, but leak into the enclosing namespace once moved into a
+        # `Data.define` block, so such a class cannot be rewritten as an assignment.
+        def defines_constants?(class_body)
+          return false unless class_body
+
+          class_body.each_node(:casgn, :class, :module).any?
+        end
+
         def correct_parent(parent, corrector)
           if parent.block_type?
             # Convert a brace block to `do`, so the class's own `end` closes it

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

@@ -4,10 +4,10 @@ module RuboCop
   module Cop
     module Style
       # Checks for directive scopes that can be expressed with the tighter
-      # `disable-next` form: a `disable`/`enable` pair wrapping exactly one
-      # statement, or a `push`/`pop` that only disables cops around exactly
-      # one statement. A statement-scoped directive cannot drift as the
-      # surrounding code changes and needs no closing boundary.
+      # next-statement forms: a `disable`/`enable` pair, an
+      # `enable`/`disable` pair, or a `push`/`pop` with signed arguments
+      # wrapping exactly one statement. A statement-scoped directive cannot
+      # drift as the surrounding code changes and needs no closing boundary.
       #
       # @safety
       #   The autocorrection is unsafe because the suppression scope shrinks
@@ -37,6 +37,21 @@ module RuboCop
       #   def foo
       #   end
       #
+      #   # bad
+      #   # rubocop:disable Metrics/AbcSize
+      #   # rubocop:push +Metrics/AbcSize
+      #   def foo
+      #   end
+      #   # rubocop:pop
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   # rubocop:enable-next Metrics/AbcSize
+      #   def foo
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
       #   # good - the region spans more than one statement
       #   # rubocop:disable Metrics/AbcSize
       #   def foo
@@ -52,7 +67,9 @@ module RuboCop
 
         MSG_PAIR = 'Use `%<mode>s-next` instead of a `%<mode>s`/`enable` pair ' \
                    'around a single statement.'
-        MSG_PUSH_POP = 'Use `disable-next` instead of `push`/`pop` around a single statement.'
+        MSG_ENABLE_PAIR = 'Use `enable-next` instead of an `enable`/`disable` pair ' \
+                          'around a single statement.'
+        MSG_PUSH_POP = 'Use `%<replacement>s` instead of `push`/`pop` around a single statement.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -61,8 +78,10 @@ module RuboCop
 
             if plain_disable?(directive)
               check_pair(directive)
-            elsif disable_only_push?(directive)
+            elsif signed_push?(directive)
               check_push_pop(directive)
+            elsif plain_enable?(directive)
+              check_enable_pair(directive)
             end
           end
         end
@@ -77,8 +96,12 @@ module RuboCop
           directive.disabled? && !directive.disable_next?
         end
 
-        def disable_only_push?(directive)
-          directive.push? && !directive.push_args.empty? && directive.push_args.keys == ['-']
+        def plain_enable?(directive)
+          directive.enabled? && !directive.enable_next? && !directive.all_cops?
+        end
+
+        def signed_push?(directive)
+          directive.push? && !directive.signed_args.empty?
         end
 
         def check_pair(directive)
@@ -100,15 +123,132 @@ module RuboCop
         end
 
         def check_push_pop(directive)
-          pop = single_statement_closing_directive(directive)
-          return unless pop&.pop?
+          pop_line = balancing_pop_line(directive)
+          return unless pop_line && comment_config.comment_only_line?(pop_line)
+          return unless wraps_single_statement?(directive, pop_line)
 
-          add_offense(directive.comment, message: MSG_PUSH_POP) do |corrector|
-            corrector.replace(directive.comment, disable_next_replacement(directive))
-            remove_line(corrector, pop.comment)
+          pop_comment = processed_source.comment_at_line(pop_line)
+          replacement = push_replacement(directive)
+          message = format(MSG_PUSH_POP, replacement: replacement_mode(directive))
+          add_offense(directive.comment, message: message) do |corrector|
+            corrector.replace(directive.comment, replacement)
+            remove_line(corrector, pop_comment)
           end
         end
 
+        # The line of the `pop` balancing this `push`, taking nesting into
+        # account, or `nil` when the push is never popped.
+        def balancing_pop_line(push_directive)
+          depth = 0
+          each_directive_after(push_directive) do |directive|
+            if directive.push?
+              depth += 1
+            elsif directive.pop?
+              return directive.line_number if depth.zero?
+
+              depth -= 1
+            end
+          end
+          nil
+        end
+
+        def each_directive_after(reference)
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            next unless directive.cop_names || directive.push? || directive.pop?
+
+            yield directive if directive.line_number > reference.line_number
+          end
+        end
+
+        def replacement_mode(directive)
+          ops = directive.signed_args.keys.sort
+          if ops == ['-']
+            'disable-next'
+          elsif ops == ['+']
+            'enable-next'
+          else
+            'next'
+          end
+        end
+
+        def push_replacement(directive)
+          text = case replacement_mode(directive)
+                 when 'disable-next'
+                   "# rubocop:disable-next #{directive.signed_args['-'].join(', ')}"
+                 when 'enable-next'
+                   "# rubocop:enable-next #{directive.signed_args['+'].join(', ')}"
+                 else
+                   "# rubocop:next #{directive.cops}"
+                 end
+          reason = directive.reason
+          reason ? "#{text} -- #{reason}" : text
+        end
+
+        # An `enable`/`disable` pair around one statement inside a disabled
+        # region re-enables the cops for just that statement - `enable-next`
+        # says the same without the closing boundary. The pair only counts
+        # when the `enable` really closed open disables (otherwise the
+        # trailing `disable` opens a new region and the conversion would
+        # change what is covered).
+        def check_enable_pair(directive)
+          closing = enable_pair_closing(directive)
+          return unless closing
+
+          add_offense(directive.comment, message: MSG_ENABLE_PAIR) do |corrector|
+            corrector.replace(directive.comment,
+                              directive.comment.text.sub(/\benable\b/, 'enable-next'))
+            remove_line(corrector, closing.comment)
+          end
+        end
+
+        def enable_pair_closing(directive)
+          scope = comment_config.statement_scope_after(directive.line_number)
+          return nil unless scope && scope.begin == directive.line_number + 1
+
+          closing = re_disable_below(directive, scope.end + 1)
+          closing if closing && closed_open_disables?(directive, closing)
+        end
+
+        def re_disable_below(directive, line)
+          return nil unless comment_config.comment_only_line?(line)
+
+          comment = processed_source.comment_at_line(line)
+          return nil unless comment
+
+          closing = DirectiveComment.new(comment)
+          return nil unless closing.disabled? && !closing.disable_next?
+          return nil unless closing.raw_cop_names.sort == directive.raw_cop_names.sort
+
+          closing
+        end
+
+        # Every cop of the pair must have a range the `enable` closed and a
+        # range the trailing `disable` reopened - otherwise the `enable` was
+        # not inside a disabled region and the conversion would change what
+        # is covered.
+        def closed_open_disables?(directive, closing)
+          directive.cop_names.all? do |cop|
+            ranges = comment_config.cop_disabled_line_ranges[qualified_name(cop)]
+            ranges && closed_at?(ranges, directive.line_number) && reopened_by?(ranges, closing)
+          end
+        end
+
+        def closed_at?(ranges, line)
+          ranges.any? { |range| range.end == line }
+        end
+
+        def reopened_by?(ranges, closing)
+          ranges.any? do |range|
+            range.respond_to?(:directive) && range.directive.comment.equal?(closing.comment)
+          end
+        end
+
+        def qualified_name(cop_name)
+          Registry.qualified_cop_name(cop_name.strip, processed_source.file_path,
+                                      correct_namespace: false)
+        end
+
         # The directive closing this one's scope, when that scope wraps
         # exactly one statement - `nil` otherwise.
         def single_statement_closing_directive(directive)
@@ -133,7 +273,7 @@ module RuboCop
           ends = ranges.map(&:end).uniq
           return nil unless ends.size == 1 && ends.first.to_f.finite?
 
-          directive.push? ? ends.first + 1 : ends.first
+          ends.first
         end
 
         def ranges_opened_by(directive)
@@ -155,13 +295,6 @@ module RuboCop
           !scope.nil? && scope.begin == directive.line_number + 1 && scope.end + 1 == closing_line
         end
 
-        def disable_next_replacement(directive)
-          cops = directive.push_args['-'].join(', ')
-          reason = directive.reason
-          text = "# rubocop:disable-next #{cops}"
-          reason ? "#{text} -- #{reason}" : text
-        end
-
         def remove_line(corrector, comment)
           corrector.remove(range_by_whole_lines(comment.source_range, include_final_newline: true))
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective -- the examples below read as real directives
 
 module RuboCop
   module Cop
@@ -12,6 +12,10 @@ module RuboCop
       # Specific cops can be allowed with the `AllowedCops` configuration. Note that
       # if this configuration is set, `rubocop:disable all` is still disallowed.
       #
+      # `AllowedCops` and `DisallowedCops` accept cop names and department names
+      # alike. Listing a cop does not cover its whole department: a directive
+      # disabling `Metrics` is broader than one disabling `Metrics/AbcSize`.
+      #
       # Alternatively, specific cops can be disallowed with the `DisallowedCops`
       # configuration. When `DisallowedCops` is set, only directives for the listed
       # cops (and `all`) will be flagged. This is useful when you want
@@ -19,7 +23,13 @@ module RuboCop
       # allowlisting all other cops. `AllowedCops` and `DisallowedCops` should not
       # both be set at the same time; if `DisallowedCops` is set, it takes precedence.
       #
-      # With `AllowTrailingComment` set to `true`, a disable directive carrying
+      # `AllowedDirectives` names directive forms - `disable`, `todo`,
+      # `disable-next`, `todo-next`, `push`, `next` - and exempts them from the
+      # cop entirely. `rubocop:todo` is the usual candidate, since
+      # `--disable-uncorrectable` generates those and they record debt rather
+      # than a decision someone should be asked to justify.
+      #
+      # With `AllowWithReason` set to `true`, a disable directive carrying
       # a `--` trailing justification comment is allowed, so a team can require
       # every disable to be documented instead of banning them outright. Enable
       # directives are not checked in this mode, since they end a suppression
@@ -58,7 +68,21 @@ module RuboCop
       #   foo
       #   # rubocop:enable Metrics/AbcSize
       #
-      # @example AllowTrailingComment: true
+      # @example AllowedDirectives: [todo]
+      #   # good - the cop does not look at `todo` directives at all
+      #   x = 0 # rubocop:todo Layout/SpaceAroundOperators
+      #
+      #   # bad
+      #   x = 0 # rubocop:disable Layout/SpaceAroundOperators
+      #
+      # @example AllowedCops: [Metrics]
+      #   # good - every cop the directive disables is in an exempt department
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      # @example AllowWithReason: true
       #   # bad
       #   x = 0 # rubocop:disable Layout/SpaceAroundOperators
       #
@@ -77,7 +101,7 @@ module RuboCop
         def on_new_investigation
           processed_source.comments.each do |comment|
             directive = DirectiveComment.new(comment)
-            next if allow_trailing_comment? && (directive.reason || directive.enabled?)
+            next if ignored?(directive)
 
             directive_cops = directive_cops(directive)
             disallowed_cops = compute_disallowed_cops(directive_cops)
@@ -95,10 +119,10 @@ module RuboCop
             if directive_cops.include?('all')
               directive_cops
             else
-              directive_cops.uniq.select { |cop| disallowed_cops_config.include?(cop) }
+              directive_cops.uniq.select { |cop| listed?(disallowed_cops_config, cop) }
             end
           else
-            directive_cops.reject { |cop| allowed_cops.include?(cop) }
+            directive_cops.reject { |cop| cop != 'all' && listed?(allowed_cops, cop) }
           end
         end
 
@@ -116,7 +140,7 @@ module RuboCop
         end
 
         def offense_message(disallowed_cops)
-          if allow_trailing_comment?
+          if allow_with_reason?
             MSG_MISSING_REASON
           elsif any_cops_allowed? || disallowed_cops_config.any?
             format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
@@ -130,14 +154,34 @@ module RuboCop
           match_captures && match_captures[1] ? match_captures[1].split(',').map(&:strip) : []
         end
 
-        def allow_trailing_comment?
-          cop_config['AllowTrailingComment']
+        def ignored?(directive)
+          return true if exempt_mode?(directive)
+
+          allow_with_reason? && (directive.reason || directive.enabled?)
+        end
+
+        def exempt_mode?(directive)
+          allowed_directives.include?(directive.mode)
+        end
+
+        def allowed_directives
+          @allowed_directives ||= Array(cop_config['AllowedDirectives'])
+        end
+
+        def allow_with_reason?
+          cop_config['AllowWithReason']
         end
 
         def allowed_cops
           @allowed_cops ||= Array(cop_config['AllowedCops']).to_set
         end
 
+        # A name matches either outright or through its department, so
+        # `Metrics` covers `Metrics/AbcSize` but not the other way round.
+        def listed?(names, cop)
+          names.include?(cop) || names.include?(cop.split('/').first)
+        end
+
         def any_cops_allowed?
           allowed_cops.any?
         end

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

@@ -119,6 +119,7 @@ module RuboCop
 
         def on_def(node)
           return if node.method?(:initialize)
+          return if allowed_methods.include?(node.method_name)
 
           parent = node.parent
           modifier_node?(parent) ? check(parent) : check(node)
@@ -130,7 +131,6 @@ module RuboCop
         def check(node)
           return if non_public?(node) && !require_for_non_public_methods?
           return if documentation_comment?(node)
-          return if method_allowed?(node)
 
           add_offense(node)
         end
@@ -139,14 +139,6 @@ module RuboCop
           cop_config['RequireForNonPublicMethods']
         end
 
-        def method_allowed?(node)
-          # For a modifier form like `module_function def foo; end`, `node` is the
-          # `module_function`/`ruby2_keywords` send; the real method name is on its
-          # `def`/`defs` argument, not the modifier itself.
-          method_name = node.send_type? ? node.first_argument.method_name : node.method_name
-          allowed_methods.include?(method_name)
-        end
-
         def allowed_methods
           @allowed_methods ||= cop_config.fetch('AllowedMethods', []).map(&:to_sym)
         end

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

@@ -26,7 +26,7 @@ module RuboCop
 
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- only matches blocks that take no parameters
           return unless offending?(node)
 
           send_node = node.send_node

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

@@ -28,7 +28,7 @@ module RuboCop
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the offense is an empty `||`
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the offense is an empty `()`
           send_node = node.send_node
           return unless send_node.send_type?
 

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

@@ -53,11 +53,11 @@ module RuboCop
 
         def on_def(node)
           return if node.body || processed_source.contains_comment?(node.source_range)
-          return if correct_style?(node)
+          return if correct_style?(node) || compact_style_disallowed?
 
           add_offense(node) do |corrector|
             correction = corrected(node)
-            next if compact_style? && max_line_length && correction.size > max_line_length
+            next if correction_exceeds_line_length?(correction)
 
             corrector.replace(node, correction)
           end
@@ -74,6 +74,12 @@ module RuboCop
           (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
+        def compact_style_disallowed?
+          return false unless compact_style?
+
+          config.for_enabled_cop('Style/SingleLineMethods')['AllowIfMethodIsEmpty'] == false
+        end
+
         def corrected(node)
           scope = node.receiver ? "#{node.receiver.source}." : ''
           arguments = if node.arguments?
@@ -86,6 +92,10 @@ module RuboCop
           ["def #{signature}", 'end'].join(joint(node))
         end
 
+        def correction_exceeds_line_length?(correction)
+          compact_style? && max_line_length && correction.size > max_line_length
+        end
+
         def joint(node)
           indent = ' ' * node.loc.column
 

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

@@ -166,6 +166,8 @@ module RuboCop
           return if node.single_line? || style == :allow_always
 
           add_offense(node, message: MSG_MULTI_LINE) do |corrector|
+            next if endless_parent?(node)
+
             correct_to_multiline(corrector, node)
           end
         end
@@ -175,11 +177,11 @@ module RuboCop
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
-          elsif !node.endless? && can_be_made_endless?(node) && node.body.single_line?
+          elsif !node.endless? && can_be_made_endless?(node) && single_line_when_made_endless?(node)
             return if too_long_when_made_endless?(node)
 
             add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
-              corrector.replace(node, endless_replacement(node))
+              correct_to_endless(corrector, node)
             end
           end
         end
@@ -189,14 +191,22 @@ module RuboCop
           return if too_long_when_made_endless?(node)
 
           add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
-            corrector.replace(node, endless_replacement(node))
+            correct_to_endless(corrector, node)
           end
         end
 
         def handle_disallow_style(node)
           return unless node.endless?
 
-          add_offense(node) { |corrector| correct_to_multiline(corrector, node) }
+          add_offense(node) do |corrector|
+            next if endless_parent?(node)
+
+            correct_to_multiline(corrector, node)
+          end
+        end
+
+        def endless_parent?(node)
+          node.parent&.any_def_type? && node.parent.endless?
         end
 
         def use_heredoc?(node)
@@ -206,6 +216,17 @@ module RuboCop
           body.each_descendant(:str).any?(&:heredoc?)
         end
 
+        def correct_to_endless(corrector, node)
+          corrector.replace(signature_to_body_range(node), ' = ')
+          corrector.remove(node.body.source_range.end.join(node.loc.end.end))
+        end
+
+        def signature_to_body_range(node)
+          signature_end = node.arguments.any? ? node.arguments.source_range.end : node.loc.name.end
+
+          signature_end.join(node.body.source_range.begin)
+        end
+
         def endless_replacement(node)
           <<~RUBY.strip
             def #{receiver(node)}#{node.method_name}#{arguments(node)} = #{node.body.source}
@@ -221,19 +242,17 @@ module RuboCop
         end
 
         def can_be_made_endless?(node)
-          node.body && !node.body.begin_type? && !node.body.kwbegin_type?
+          node.body && !node.body.type?(:begin, :kwbegin, :rescue, :ensure)
+        end
+
+        def single_line_when_made_endless?(node)
+          !endless_replacement(node).include?("\n")
         end
 
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')
 
-          offset = modifier_offset(node)
-
-          endless_replacement(node).length + offset > max_line_length
-        end
-
-        def modifier_offset(node)
-          same_line?(node.parent, node) ? node.loc.column - node.parent.loc.column : 0
+          endless_replacement(node).length + node.loc.column > max_line_length
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
           @contain_dev_null_string_in_file = ast.each_descendant(:str).any? do |str|
             content = str.str_content
 
-            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull
+            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           end
         end
 
@@ -62,7 +62,7 @@ module RuboCop
           value = node.value
           return unless valid_string?(value)
           return if acceptable?(node)
-          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull
+          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull -- the cop needs the literal it is matching
           return unless REGEXP.match?(value)
 
           add_offense(node, message: format(MSG, source: value)) do |corrector|