rubocop 1.86.2 → 1.87.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # Checks for Regexps (both literals and via `Regexp.new` / `Regexp.compile`)
       # that contain unescaped `]` characters.
       #
       # It emulates the following Ruby warning:

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in `begin` (implicit) blocks.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #

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

@@ -6,7 +6,7 @@ module RuboCop
       # Looks for `ruby2_keywords` calls for methods that do not need it.
       #
       # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # (`\*args`) but do not have explicit keyword arguments (`k:` or `k: true`) or
       # a keyword splat (`**kwargs`).
       #
       # @example

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

@@ -17,7 +17,7 @@ module RuboCop
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
-      # instead. By default, there are no methods to allowed.
+      # instead. By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #

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

@@ -15,7 +15,7 @@ module RuboCop
       # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
       # deprecated and only kept for backwards compatibility.
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example CountAsOne: ['array', 'hash', 'heredoc', 'method_call']
       #

data/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -43,7 +43,7 @@ module RuboCop
             end
           end
 
-          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+          # Returns true only when name is a known iterating type (e.g. :each, :transform_values).
           def iterating_method?(name)
             KNOWN_ITERATING_METHODS.include? name
           end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common helpers for cops that consult the project-wide static-analysis index
+    # via `Cop::Base#project_index`.
+    #
+    # Mixed-in cops gain the `external_dependency_checksum` override that invalidates
+    # the `ResultCache` whenever the indexed project files change on disk.
+    # To run index-backed analysis, cops should simply check whether `project_index` is non-nil;
+    # the runner only exposes a non-nil index when the user opted in via `AllCops/UseProjectIndex`
+    # and the underlying gem is available.
+    module ProjectIndexHelp
+      BUILTIN_DOCUMENT_URI = 'rubydex:built-in'
+      FILE_URI_PREFIX = 'file://'
+      # Matches the spurious leading slash before a Windows drive letter that
+      # remains after stripping `file://` from a `file:///C:/...` URI.
+      WINDOWS_DRIVE_PREFIX = %r{\A/(?=[A-Za-z]:[/\\])}.freeze
+
+      def external_dependency_checksum
+        return nil unless project_index
+
+        @external_dependency_checksum ||= Digest::SHA1.hexdigest(
+          project_index_signature.join("\n")
+        )
+      end
+
+      private
+
+      def project_index_signature
+        project_index.documents.filter_map do |doc|
+          uri = doc.uri
+          next if uri == BUILTIN_DOCUMENT_URI
+
+          path = uri.delete_prefix(FILE_URI_PREFIX).sub(WINDOWS_DRIVE_PREFIX, '')
+          mtime, size = begin
+            stat = File.stat(path)
+            [stat.mtime.to_f, stat.size]
+          rescue StandardError
+            [0, 0]
+          end
+
+          "#{path}:#{mtime}:#{size}"
+        end.sort
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin.rb

@@ -28,6 +28,7 @@ module RuboCop
     autoload :DocumentationComment, 'rubocop/cop/mixin/documentation_comment'
     autoload :Duplication, 'rubocop/cop/mixin/duplication'
     autoload :RangeHelp, 'rubocop/cop/mixin/range_help'
+    autoload :ProjectIndexHelp, 'rubocop/cop/mixin/project_index_help'
     autoload :AnnotationComment, 'rubocop/cop/mixin/annotation_comment'
     autoload :EmptyParameter, 'rubocop/cop/mixin/empty_parameter'
     autoload :EndKeywordAlignment, 'rubocop/cop/mixin/end_keyword_alignment'

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Naming
       # Makes sure that certain binary operator methods have their
-      # sole  parameter named `other`.
+      # sole parameter named `other`.
       #
       # @example
       #

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks that predicate methods end with `?` and non-predicate methods do not.
       #
       # The names of predicate methods (methods that return a boolean value) should end
-      # in a question mark. Methods that don't return a boolean, shouldn't
+      # in a question mark. Methods that don't return a boolean shouldn't
       # end in a question mark.
       #
       # The cop assesses a predicate method as one that returns boolean values. Likewise,
@@ -22,7 +22,7 @@ module RuboCop
       # return values are detected.
       #
       # The cop also has `AllowedMethods` configuration in order to prevent the cop from
-      # registering an offense from a method name that does not confirm to the naming
+      # registering an offense from a method name that does not conform to the naming
       # guidelines. By default, `call` is allowed. The cop also has `AllowedPatterns`
       # configuration to allow method names by regular expression.
       #

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

@@ -17,7 +17,7 @@ module RuboCop
       # they end with a `?`. These methods should be changed to remove the
       # prefix.
       #
-      # When `UseSorbetSigs` set to true (optional), the cop will only report
+      # When `UseSorbetSigs` is set to true (optional), the cop will only report
       # offenses if the method has a Sorbet `sig` with a return type of
       # `T::Boolean`. Dynamic methods are not supported with this configuration.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that rescued exceptions variables are named as
+      # Makes sure that rescued exception variables are named as
       # expected.
       #
       # The `PreferredName` config option takes a `String`. It represents

data/lib/rubocop/cop/registry.rb

@@ -51,6 +51,7 @@ module RuboCop
       def initialize(cops = [], options = {})
         @departments = Set.new
         @cops_by_badge = {}
+        @lazy_loaded_cops_by_badge = {}
 
         @enrollment_queue = cops
         @options = options
@@ -60,6 +61,12 @@ module RuboCop
         @warnings = {}
       end
 
+      def lazy_load(cop_name, constant_name)
+        badge = Badge.parse(cop_name)
+        @departments << badge.department
+        @lazy_loaded_cops_by_badge[badge] = constant_name
+      end
+
       def enlist(cop)
         @enrollment_queue << cop
       end
@@ -154,8 +161,8 @@ module RuboCop
       def unqualified_cop_names
         clear_enrollment_queue
         @unqualified_cop_names ||=
-          Set.new(@cops_by_badge.keys.map { |badge| File.basename(badge.to_s) }) <<
-          'RedundantCopDisableDirective'
+          (@cops_by_badge.keys | @lazy_loaded_cops_by_badge.keys)
+          .to_set { |badge| File.basename(badge.to_s) } << 'RedundantCopDisableDirective'
       end
 
       def qualify_badge(badge)
@@ -168,17 +175,19 @@ module RuboCop
       # @return [Hash{String => Array<Class>}]
       def to_h
         clear_enrollment_queue
+        load_all_lazy_cops
         @cops_by_badge.to_h { |_badge, cop| [cop.cop_name, [cop]] }
       end
 
       def cops
         clear_enrollment_queue
+        load_all_lazy_cops
         @cops_by_badge.values
       end
 
       def length
         clear_enrollment_queue
-        @cops_by_badge.size
+        @cops_by_badge.size + @lazy_loaded_cops_by_badge.size
       end
 
       def enabled(config)
@@ -214,7 +223,7 @@ module RuboCop
 
       def names
         clear_enrollment_queue
-        @cops_by_badge.keys.map(&:to_s)
+        @cops_by_badge.keys.map(&:to_s) | @lazy_loaded_cops_by_badge.keys.map(&:to_s)
       end
 
       def cops_for_department(department)
@@ -231,6 +240,7 @@ module RuboCop
 
       def sort!
         clear_enrollment_queue
+        load_all_lazy_cops
         @cops_by_badge = @cops_by_badge.sort_by { |badge, _cop| badge.cop_name }.to_h
 
         self
@@ -249,7 +259,7 @@ module RuboCop
       def find_by_cop_name(cop_name)
         clear_enrollment_queue
         badge = Badge.parse(cop_name)
-        @cops_by_badge[badge]
+        @cops_by_badge[badge] || load_lazy_cop(badge)
       end
 
       # When a cop name is given returns a single-element array with the cop class.
@@ -262,6 +272,7 @@ module RuboCop
 
       def freeze
         clear_enrollment_queue
+        load_all_lazy_cops
         unqualified_cop_names # build cache
         super
       end
@@ -292,6 +303,17 @@ module RuboCop
         @enrollment_queue = []
       end
 
+      def load_all_lazy_cops
+        @lazy_loaded_cops_by_badge.each_key { |badge| load_lazy_cop(badge) }
+      end
+
+      def load_lazy_cop(badge)
+        constant_name = @lazy_loaded_cops_by_badge.delete(badge)
+        return unless constant_name
+
+        @cops_by_badge[badge] = Kernel.const_get(constant_name)
+      end
+
       def with(cops)
         self.class.new(cops)
       end
@@ -313,7 +335,7 @@ module RuboCop
 
       def registered?(badge)
         clear_enrollment_queue
-        @cops_by_badge.key?(badge)
+        @cops_by_badge.key?(badge) || @lazy_loaded_cops_by_badge.key?(badge)
       end
     end
   end

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

@@ -10,7 +10,7 @@ module RuboCop
       # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
       # `Kernel#open` may allow unintentional command injection, which is the reason these
       # `IO` methods are a security risk.
-      # Consider to use `File.read` to disable the behavior of subprocess invocation.
+      # Consider using `File.read` to disable the behavior of subprocess invocation.
       #
       # @safety
       #   This cop is unsafe because false positive will occur if the variable passed as

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

@@ -10,7 +10,7 @@ module RuboCop
       # is resolved at runtime).
       # It also flags uses of `alias :symbol` rather than `alias bareword`.
       #
-      # However, it will always enforce `method_alias` when used `alias`
+      # However, it will always enforce `alias_method` when `alias` is used
       # in an instance method definition and in a singleton method definition.
       # If used in a block, always enforce `alias_method`
       # unless it is an `instance_eval` block.
@@ -45,6 +45,7 @@ module RuboCop
           return unless node.command?(:alias_method)
           return unless style == :prefer_alias && alias_keyword_possible?(node)
           return unless node.arguments.count == 2
+          return if alias_method_value_used?(node)
 
           msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
           add_offense(node.loc.selector, message: msg) do |corrector|
@@ -80,6 +81,14 @@ module RuboCop
           scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
         end
 
+        # `alias_method` is a method call whose return value can be used
+        # (e.g., as an argument to `public`/`module_function`, or as an assignment),
+        # but `alias` is a keyword statement that cannot appear in such positions.
+        # Detect these positions so the conversion does not produce a syntax error.
+        def alias_method_value_used?(node)
+          node.argument? || node.parent&.assignment?
+        end
+
         def alias_method_possible?(node)
           scope_type(node) != :instance_eval &&
             node.children.none?(&:gvar_type?) &&

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

@@ -8,8 +8,8 @@ module RuboCop
       # essentially one-character strings, so this syntax
       # is mostly redundant at this point.
       #
-      # ? character literal can be used to express meta and control character.
-      # That's a good use case of ? literal so it doesn't count it as an offense.
+      # A `?` character literal can be used to express meta and control characters.
+      # That's a good use case of a `?` literal so it doesn't count as an offense.
       #
       # @example
       #   # bad

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

@@ -181,6 +181,7 @@ module RuboCop
 
         def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
+          return unless const_namespace?(node.identifier.namespace)
 
           if style == :nested
             check_nested_style(node)
@@ -189,6 +190,13 @@ module RuboCop
           end
         end
 
+        def const_namespace?(node)
+          return true if node.nil? || node.cbase_type?
+          return false unless node.const_type?
+
+          const_namespace?(node.namespace)
+        end
+
         def check_nested_style(node)
           return unless compact_node_name?(node)
           return if node.parent&.type?(:class, :module)

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

@@ -6,7 +6,7 @@ module RuboCop
   module Cop
     module Style
       # Detects comments to enable/disable RuboCop.
-      # This is useful if want to make sure that every RuboCop error gets fixed
+      # This is useful if you want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
       # Specific cops can be allowed with the `AllowedCops` configuration. Note that

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

@@ -104,28 +104,30 @@ module RuboCop
 
         def replacement(mode, filename, content, write_node)
           replacement = "#{write_method(mode)}(#{filename.source}, #{content.source})"
+          heredoc = heredoc_in_write(write_node)
+          return replacement unless heredoc
 
-          if heredoc?(write_node)
-            first_argument = write_node.body.first_argument
+          <<~REPLACEMENT.chomp
+            #{replacement}
+            #{heredoc_range(heredoc).source}
+          REPLACEMENT
+        end
 
-            <<~REPLACEMENT.chomp
-              #{replacement}
-              #{heredoc_range(first_argument).source}
-            REPLACEMENT
-          else
-            replacement
-          end
+        def heredoc_in_write(write_node)
+          return unless write_node.block_type? && (first_argument = write_node.body.first_argument)
+
+          find_heredoc(first_argument)
         end
 
-        def heredoc?(write_node)
-          write_node.block_type? && (first_argument = write_node.body.first_argument) &&
-            first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+        def heredoc_range(heredoc)
+          range_between(heredoc.loc.heredoc_body.begin_pos, heredoc.loc.heredoc_end.end_pos)
         end
 
-        def heredoc_range(first_argument)
-          range_between(
-            first_argument.loc.heredoc_body.begin_pos, first_argument.loc.heredoc_end.end_pos
-          )
+        def find_heredoc(node)
+          return node if node.respond_to?(:heredoc?) && node.heredoc?
+          return if node.send_type? && !(receiver = node.receiver)
+
+          find_heredoc(receiver)
         end
       end
     end

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

@@ -11,9 +11,10 @@ module RuboCop
       # if the first argument is a string literal and if the second
       # argument is an array literal.
       #
-      # Autocorrection will be applied when using argument is a literal or known built-in conversion
-      # methods such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`, and `to_sym` on variables,
-      # provided that their return value is not an array. For example, when using `to_s`,
+      # Autocorrection will be applied when the argument is a literal or uses a known
+      # built-in conversion method such as `to_d`, `to_f`, `to_h`, `to_i`, `to_r`, `to_s`,
+      # and `to_sym` on variables, provided that their return value is not an array.
+      # For example, when using `to_s`,
       # `'%s' % [1, 2, 3].to_s` can be autocorrected without any incompatibility:
       #
       # [source,ruby]

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

@@ -73,7 +73,7 @@ module RuboCop
           first_argument = node.first_argument
           if first_argument.hash_type?
             register_offense_for_hash(node, first_argument)
-          elsif first_argument.splat_type?
+          elsif first_argument.type?(:splat, :forwarded_restarg)
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
           elsif use_zip_method_without_argument?(first_argument)
             register_offense_for_zip_method(node, first_argument)

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

@@ -10,7 +10,7 @@ module RuboCop
       # Required capitalization can be set with the `DirectiveCapitalization` and
       # `ValueCapitalization` configuration keys.
       #
-      # NOTE: If one of these configuration is set to nil, any capitalization is allowed.
+      # NOTE: If one of these configurations is set to nil, any capitalization is allowed.
       #
       # @example EnforcedStyle: snake_case (default)
       #   # The `snake_case` style will enforce that the frozen string literal

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

@@ -6,7 +6,7 @@ module RuboCop
       # Enforces the use of `max` or `min` instead of comparison for greater or less.
       #
       # NOTE: It can be used if you want to present limit or threshold in Ruby 2.7+.
-      # That it is slow though. So autocorrection will apply generic `max` or `min`:
+      # It is slow though. So autocorrection will apply generic `max` or `min`:
       #
       # [source,ruby]
       # ----

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for the instantiation of array using redundant `Array` constructor.
-      # Autocorrect replaces to array literal which is the simplest and fastest.
+      # Checks for the instantiation of an array using a redundant `Array` constructor.
+      # Autocorrect replaces it with an array literal which is the simplest and fastest.
       #
       # @example
       #

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

@@ -3,16 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # Avoid redundant `::` prefix on constant.
+      # Avoid redundant `::` prefix on a constant.
       #
-      # How Ruby searches constant is a bit complicated, and it can often be difficult to
+      # How Ruby searches constants is a bit complicated, and it can often be difficult to
       # understand from the code whether the `::` is intended or not. Where `Module.nesting`
       # is empty, there is no need to prepend `::`, so it would be nice to consistently
       # avoid such meaningless `::` prefix to avoid confusion.
       #
-      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # `Lint/ConstantResolution` cop which is disabled by default.
+      # NOTE: This cop is disabled if `Lint/ConstantResolution` cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable `Lint/ConstantResolution` cop which is disabled by default.
       #
       # @example
       #   # bad

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
-      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      # Checks for the instantiation of a regexp using a redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces it with a regexp literal which is the simplest and fastest.
       #
       # @example
       #

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Enforces using `//` or `%r` around regular expressions.
       #
-      # NOTE: The following `%r` cases using a regexp starts with a blank or `=`
-      # as a method argument allowed to prevent syntax errors.
+      # NOTE: The following `%r` cases using a regexp that starts with a blank or `=`
+      # as a method argument are allowed to prevent syntax errors.
       #
       # [source,ruby]
       # ----

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

@@ -3,17 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of `rescue` in its modifier form is added for following
+      # Checks for uses of `rescue` in its modifier form. It is added for the following
       # reasons:
       #
       # * The syntax of modifier form `rescue` can be misleading because it
       #   might lead us to believe that `rescue` handles the given exception
-      #   but it actually rescue all exceptions to return the given rescue
+      #   but it actually rescues all exceptions to return the given rescue
       #   block. In this case, value returned by handle_error or
       #   SomeException.
       #
       # * Modifier form `rescue` would rescue all the exceptions. It would
-      #   silently skip all exception or errors and handle the error.
+      #   silently skip all exceptions or errors and handle the error.
       #   Example: If `NoMethodError` is raised, modifier form rescue would
       #   handle the exception.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces the use the shorthand for self-assignment.
+      # Enforces the use of the shorthand for self-assignment.
       #
       # @example
       #

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

@@ -61,6 +61,8 @@ module RuboCop
             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))
+          elsif unparenthesized_struct_new?(parent)
+            wrap_unparenthesized_call_with_do(corrector, parent)
           else
             corrector.insert_after(parent, ' do')
           end
@@ -73,6 +75,17 @@ module RuboCop
             range_by_whole_lines(class_node.loc.end, include_final_newline: true)
           end
         end
+
+        def unparenthesized_struct_new?(parent)
+          parent.send_type? && parent.arguments.any? && !parent.parenthesized?
+        end
+
+        def wrap_unparenthesized_call_with_do(corrector, parent)
+          args_source = parent.arguments.map(&:source).join(', ')
+          range = parent.loc.selector.end.join(parent.source_range.end)
+
+          corrector.replace(range, "(#{args_source}) do")
+        end
       end
     end
   end

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

@@ -3,11 +3,11 @@
 module RuboCop
   module Cop
     module Style
-      # Newcomers to ruby applications may write top-level methods,
+      # Newcomers to Ruby applications may write top-level methods,
       # when ideally they should be organized in appropriate classes or modules.
       # This cop looks for definitions of top-level methods and warns about them.
       #
-      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # However, for Ruby scripts it is perfectly fine to use top-level methods.
       # Hence this cop is disabled by default.
       #
       # @example

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

@@ -14,11 +14,11 @@ module RuboCop
       #
       # `forbid_mixed_logical_operators` style forbids the use of more than one type
       # of logical operators. This makes the `unless` condition easier to read
-      # because either all conditions need to be met or any condition need to be met
+      # because either all conditions need to be met or any condition needs to be met
       # in order for the expression to be truthy or falsey.
       #
-      # `forbid_logical_operators` style forbids any use of logical operator.
-      # This makes it even more easy to read the `unless` condition as
+      # `forbid_logical_operators` style forbids any use of logical operators.
+      # This makes it even easier to read the `unless` condition as
       # there is only one condition in the expression.
       #
       # @example EnforcedStyle: forbid_mixed_logical_operators (default)

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

@@ -147,7 +147,7 @@ module RuboCop
         end
 
         def constant_portion?(node)
-          node.literal? || node.const_type?
+          node.recursive_literal? || node.const_type?
         end
 
         def actual_code_range(node)

data/lib/rubocop/file_patterns.rb

@@ -21,11 +21,19 @@ module RuboCop
     def initialize(patterns)
       @strings = Set.new
       @patterns = []
+      @match_cache = {}
       partition_patterns(patterns)
     end
 
     def match?(path)
-      @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
+      # `FilePatterns.from` memoizes one instance per pattern array (by identity),
+      # so this cache is shared across every cop using the same Include/Exclude
+      # list. Patterns are immutable within a run, so caching by path is safe.
+      cached = @match_cache[path]
+      return cached unless cached.nil?
+
+      @match_cache[path] =
+        @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
     end
 
     private