rubocop 1.89.0 → 1.91.0

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Shared machinery for cops that compare a call site's arguments against
+    # a method signature from the project index (`Rubydex::Signature`).
+    #
+    # A signature is reduced to a shape - `[min, max, has_keywords]` where
+    # `max` is nil for a rest parameter - and the number of positional
+    # arguments a call passes is counted with Ruby's semantics for trailing
+    # keyword hashes: keywords passed to a method with no keyword parameters
+    # collapse into a single positional hash.
+    module IndexedMethodArity
+      private
+
+      def arity_satisfied?(given, min, max)
+        given >= min && (max.nil? || given <= max)
+      end
+
+      def expected_range(min, max)
+        return "#{min}+" if max.nil?
+        return min.to_s if min == max
+
+        "#{min}..#{max}"
+      end
+
+      # The agreed `[min, max, has_keywords]` shape of an indexed member's
+      # method definitions, or nil when the member is not backed by plain
+      # method definitions (attr, alias), has no signature, forwards
+      # arguments, or its definitions disagree on arity (e.g. reopened with
+      # a different one).
+      def indexed_member_shape(member)
+        definitions = member.definitions.grep(Rubydex::MethodDefinition)
+        return nil if definitions.empty?
+
+        signature_shape(definitions.flat_map(&:signatures))
+      end
+
+      def signature_shape(signatures)
+        shapes = signatures.filter_map { |signature| shape_for(signature) }.uniq
+        shapes.one? ? shapes.first : nil
+      end
+
+      def shape_for(signature)
+        return nil if signature.forward_parameter
+
+        min = signature.positional_parameters.size + signature.post_parameters.size
+
+        [min, maximum_positional(signature, min), keyword_parameters?(signature)]
+      end
+
+      def maximum_positional(signature, min)
+        return nil if signature.rest_positional_parameter
+
+        min + signature.optional_positional_parameters.size
+      end
+
+      def keyword_parameters?(signature)
+        !signature.keyword_parameters.empty? ||
+          !signature.optional_keyword_parameters.empty? ||
+          !signature.rest_keyword_parameter.nil?
+      end
+
+      # The number of positional arguments the call passes, or nil when it
+      # cannot be determined statically (argument forwarding).
+      def positional_argument_count(node, callee_has_keywords)
+        arguments = node.arguments
+        return nil if forwards_arguments?(arguments)
+
+        arguments = arguments[0...-1] if arguments.last&.block_pass_type?
+        return arguments.size unless (keyword_hash = keyword_hash(arguments.last))
+        return nil if double_splat?(keyword_hash)
+
+        # A keyword-style hash passed to a method with no keyword parameters is
+        # received as a single positional hash argument.
+        callee_has_keywords ? arguments.size - 1 : arguments.size
+      end
+
+      def forwards_arguments?(arguments)
+        arguments.any? do |argument|
+          argument.type?(:splat, :forwarded_args, :forwarded_restarg, :forwarded_kwrestarg)
+        end
+      end
+
+      def keyword_hash(node)
+        node if node&.hash_type? && !node.braces?
+      end
+
+      def double_splat?(hash_node)
+        hash_node.each_child_node.any?(&:kwsplat_type?)
+      end
+    end
+  end
+end

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

@@ -128,7 +128,13 @@ module RuboCop
           # Additionally, the RFC2396_PARSER alias is only available on 3.4 for now.
           # Extra info at https://github.com/ruby/uri/issues/118
           parser = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
-          parser.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+          schemes = config.for_cop('Layout/LineLength')['URISchemes']
+          regexp = parser.make_regexp(schemes)
+
+          # `make_regexp` in uri 1.1.0+ matches schemes case-insensitively, which makes
+          # constant paths like `Http::UploadedFile` look like URIs. Require the exact case
+          # given in `URISchemes`.
+          schemes ? /(?=#{Regexp.union(schemes)}:)#{regexp}/ : regexp
         end
       end
 

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module PrecedingFollowingAlignment
       # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
       # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
@@ -69,7 +69,15 @@ module RuboCop
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
-          next if indent && indent != index
+
+          if indent
+            # When searching for the nearest line with the same indentation,
+            # more deeply indented lines are nested content of the current group
+            # and are skipped, but a less deeply indented line ends the enclosing block:
+            # an alignment anchor beyond it would be coincidental.
+            break if index < indent
+            next if index > indent
+          end
 
           return yield(range, line, lineno + 1)
         end
@@ -174,20 +182,69 @@ module RuboCop
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
       def relevant_assignment_lines(line_range)
+        relevant_lines(line_range, interrupting_operator_lines) do |line_number|
+          assignment_lines.include?(line_number)
+        end
+      end
+
+      def interrupting_operator_lines
+        @interrupting_operator_lines ||=
+          processed_source.tokens.each_with_object(Set.new) do |token, lines|
+            next unless ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type)
+
+            lines << token.line unless assignment_lines.include?(token.line)
+          end
+      end
+
+      def alignment_lines(line_number)
+        @alignment_lines_by_line ||= {}
+        return @alignment_lines_by_line[line_number] if @alignment_lines_by_line.key?(line_number)
+
+        lines = alignment_line_ranges(line_number).flatten.uniq.sort.freeze
+
+        lines.each { |line| @alignment_lines_by_line[line] = lines }
+      end
+
+      def alignment_line_ranges(line_number)
+        last_line = processed_source.lines.length
+
+        [
+          relevant_lines(line_number.downto(1), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end,
+          relevant_lines(line_number.upto(last_line), definition_boundary_lines) do |line|
+            !aligned_comment_lines.include?(line)
+          end
+        ]
+      end
+
+      def definition_boundary_lines
+        @definition_boundary_lines ||= begin
+          nodes = processed_source.ast&.each_node(:any_def) || []
+
+          nodes.each_with_object(Set.new) do |node, lines|
+            lines << node.first_line << node.last_line
+          end
+        end
+      end
+
+      def relevant_lines(line_range, boundary_lines = [])
         result                        = []
-        original_line_indent          = processed_source.line_indentation(line_range.first)
+        original_line                 = line_range.first
+        original_line_indent          = processed_source.line_indentation(original_line)
         relevant_line_indent_at_level = true
 
         line_range.each do |line_number|
           current_line_indent = processed_source.line_indentation(line_number)
           blank_line          = processed_source.lines[line_number - 1].blank?
 
-          if (current_line_indent < original_line_indent && !blank_line) ||
+          if (line_number != original_line && boundary_lines.include?(line_number)) ||
+             (current_line_indent < original_line_indent && !blank_line) ||
              (relevant_line_indent_at_level && blank_line)
             break
           end
 
-          result << line_number if assignment_lines.include?(line_number) &&
+          result << line_number if yield(line_number) &&
                                    current_line_indent == original_line_indent
 
           unless blank_line
@@ -214,6 +271,5 @@ module RuboCop
         asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

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

@@ -116,14 +116,13 @@ module RuboCop
         end
       end
 
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable-next Metrics/ParameterLists
       def final_pos(src, pos, increment, continuations, newlines, whitespace)
         pos = move_pos(src, pos, increment, true, /[ \t]/)
         pos = move_pos_str(src, pos, increment, continuations, "\\\n")
         pos = move_pos(src, pos, increment, newlines, /\n/)
         move_pos(src, pos, increment, whitespace, /\s/)
       end
-      # rubocop:enable Metrics/ParameterLists
 
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0

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

@@ -35,8 +35,14 @@ module RuboCop
         condition.each_node.any?(&:lvasgn_type?)
       end
 
+      # The rendered modifier form is compared against the bare maximum, not
+      # `acceptable_line_length?`: `Layout/LineLength`'s exemptions describe
+      # long lines the user tolerates, not permission to manufacture new ones,
+      # so collapsing to modifier form must never push a line past the maximum.
       def modifier_fits_on_single_line?(node)
-        acceptable_line_length?(line_in_modifier_form(node), node.first_line)
+        return true unless max_line_length
+
+        line_length(line_in_modifier_form(node)) <= max_line_length
       end
 
       def line_in_modifier_form(node)
@@ -46,12 +52,12 @@ module RuboCop
         "#{code_before}#{to_modifier_form(node)}#{code_after(node)}"
       end
 
-      # Rather than comparing the rendered modifier form against the bare
-      # maximum, ask the question `Layout/LineLength` would: a line the user's
-      # configuration exempts (`Layout/LineLength` disabled at that line, an
-      # allowed pattern, an allowed cop directive, an allowed URI) fits by
-      # definition. This keeps every modifier cop consistent with
-      # `Layout/LineLength` instead of each reimplementing part of its policy.
+      # Whether an existing line is acceptable to `Layout/LineLength`,
+      # exemptions (the cop disabled at that line, an allowed pattern, an
+      # allowed cop directive, an allowed URI) included. Only for judging
+      # lines already in the source as too long - see
+      # `modifier_fits_on_single_line?` for why the exemptions must not apply
+      # when deciding whether a modifier line may be created.
       def acceptable_line_length?(line, line_number)
         return true unless max_line_length
         return true if line_length(line) <= max_line_length

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # Common methods shared by Style/TrailingCommaInArguments,
     # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -95,7 +95,7 @@ module RuboCop
         node.multiline? && !allowed_multiline_argument?(node)
       end
 
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def method_name_and_arguments_on_same_line?(node)
         return false if !node.call_type? || node.last_line != node.last_argument.last_line
         return true if node.last_argument.hash_type? && node.last_argument.braces?
@@ -104,7 +104,6 @@ module RuboCop
 
         line == node.last_argument.last_line
       end
-      # rubocop:enable Metrics/AbcSize
 
       # A single argument with the closing bracket on the same line as the end
       # of the argument is not considered multiline, even if the argument
@@ -223,6 +222,5 @@ module RuboCop
         false
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  module Cop # rubocop:disable Style/Documentation
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the mixins below
     # Autoloads mixin modules included by cops. Mixins are autoloaded to reduce the number of
     # requires because they're used only when the relevant cop class is loaded.
 
@@ -14,7 +14,7 @@ module RuboCop
     autoload :AllowedReceivers, "#{__dir__}/mixin/allowed_receivers"
     autoload :ForbiddenIdentifiers, "#{__dir__}/mixin/forbidden_identifiers"
     autoload :ForbiddenPattern, "#{__dir__}/mixin/forbidden_pattern"
-    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage
+    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage -- the file is named `auto_corrector.rb`
     autoload :CheckAssignment, "#{__dir__}/mixin/check_assignment"
     autoload :CheckLineBreakable, "#{__dir__}/mixin/check_line_breakable"
     autoload :CheckSingleLineSuitability, "#{__dir__}/mixin/check_single_line_suitability"
@@ -41,6 +41,10 @@ module RuboCop
     autoload :HashAlignmentStyles, "#{__dir__}/mixin/hash_alignment_styles"
     autoload :HashSubset, "#{__dir__}/mixin/hash_subset"
     autoload :HashTransformMethod, "#{__dir__}/mixin/hash_transform_method"
+    # Deprecated aliases of `AllowedMethods` and `AllowedPattern`, defined in those files.
+    autoload :IgnoredMethods, "#{__dir__}/mixin/allowed_methods"
+    autoload :IgnoredPattern, "#{__dir__}/mixin/allowed_pattern"
+    autoload :IndexedMethodArity, "#{__dir__}/mixin/indexed_method_arity"
     autoload :IntegerNode, "#{__dir__}/mixin/integer_node"
     autoload :Interpolation, "#{__dir__}/mixin/interpolation"
     autoload :LineLengthHelp, "#{__dir__}/mixin/line_length_help"

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

@@ -33,6 +33,7 @@ module RuboCop
               node.each_descendant(:lvar, :lvasgn) do |lvar|
                 lvar_location = lvar.loc.name
                 next unless lvar_location.source == arg.source
+                next if shadowed?(lvar, arg.source, node)
 
                 corrector.replace(lvar_location, 'other')
               end
@@ -47,6 +48,21 @@ module RuboCop
 
           !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
+
+        # A reference is shadowed when an enclosing block within the method redeclares the
+        # parameter name (as a block parameter or block-local). Such a reference points to
+        # the block's variable, not the operator's parameter, so it must not be renamed.
+        def shadowed?(node, name, def_node)
+          node.each_ancestor(:block).any? do |block|
+            def_node.source_range.contains?(block.source_range) && redeclares?(block, name)
+          end
+        end
+
+        def redeclares?(block, name)
+          block.arguments.any? do |argument|
+            argument.respond_to?(:name) && argument.name.to_s == name
+          end
+        end
       end
     end
   end

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

@@ -62,7 +62,10 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+          [
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding,
+            Style::ExplicitBlockArgument, Style::MethodDefParentheses
+          ]
         end
 
         def on_def(node)

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

@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- there are no parameter names to check
           return unless node.arguments?
 
           check(node, node.arguments)

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

@@ -167,7 +167,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def on_or_asgn(node)
           lhs = node.lhs
           return unless lhs.ivasgn_type?
@@ -192,7 +192,6 @@ module RuboCop
             corrector.replace(lhs.loc.name, "@#{suggested_var}")
           end
         end
-        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -203,7 +202,7 @@ module RuboCop
             $(ivasgn %1 _))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
           arg = node.first_argument
           return false unless arg.ivar_type?
@@ -233,7 +232,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 

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

@@ -105,6 +105,10 @@ module RuboCop
 
         MSG = 'Use %<style>s for method names.'
         MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
+        RESTRICT_ON_SEND = %i[
+          define_method define_singleton_method new define alias_method
+          attr attr_reader attr_writer attr_accessor
+        ].freeze
 
         OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
                               % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
@@ -209,7 +213,7 @@ module RuboCop
           forbidden_identifier?(name) || forbidden_pattern?(name)
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
         def register_forbidden_name(node)
           if node.any_def_type?
             name_node = node.loc.name
@@ -227,7 +231,6 @@ module RuboCop
           message = format(MSG_FORBIDDEN, identifier: method_name)
           add_offense(name_node, message: message)
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
         def attr_name(name_item)
           sym_name(name_item) || str_name(name_item)

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

@@ -118,7 +118,7 @@ module RuboCop
 
         # Returns the reassignment node once the exception variable is reassigned (a truthy
         # signal to stop correcting later references), or `nil` when no reassignment is found.
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
 
@@ -141,7 +141,6 @@ module RuboCop
           end
           nil
         end
-        # rubocop:enable Metrics/MethodLength
 
         # If the exception variable is reassigned, that assignment needs to be corrected.
         # Further `lvar` nodes will not be corrected though since they now refer to a

data/lib/rubocop/cop/offense.rb

@@ -86,9 +86,19 @@ module RuboCop
 
       NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
+      # @api public
+      #
+      # @!attribute [r] justification
+      #
+      # @return [String, nil]
+      #   the reason given on the directive that suppressed this offense
+      #   (the text after `--`), or `nil` when the offense is not suppressed
+      #   or the directive carries no reason
+      attr_reader :justification
+
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
-                     status = :uncorrected, corrector = nil)
+                     status = :uncorrected, corrector = nil, justification: nil)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
 
@@ -101,15 +111,16 @@ module RuboCop
         @cop_name = cop_name.freeze
         @status = status
         @corrector = corrector
+        @justification = justification.freeze
         freeze
       end
 
       def marshal_dump
-        [@severity, @location, @message, @cop_name, @status]
+        [@severity, @location, @message, @cop_name, @status, @justification]
       end
 
       def marshal_load(array)
-        @severity, @location, @message, @cop_name, @status = array
+        @severity, @location, @message, @cop_name, @status, @justification = array
         @line = @location.line
         @column = @location.column
       end
@@ -121,8 +132,10 @@ module RuboCop
       # @return [Boolean]
       #   whether this offense can be automatically corrected via autocorrect.
       #   This includes todo comments, for example when requested with `--disable-uncorrectable`.
+      #   An offense suppressed by a directive comment is not correctable -
+      #   autocorrect will not touch it.
       def correctable?
-        @status != :unsupported
+        @status != :unsupported && @status != :disabled
       end
 
       # @api public
@@ -223,6 +236,16 @@ module RuboCop
         column + 1
       end
 
+      # @api private
+      #
+      # The minimum value of `real_column` is 1, so the minimum value of
+      # `real_last_column` is also 1. A non-zero `last_column` is used as is,
+      # because the 0-based end-exclusive column is the same as the 1-based
+      # column of the last character.
+      def real_last_column
+        last_column.zero? ? 1 : last_column
+      end
+
       # @api public
       #
       # @return [Boolean]

data/lib/rubocop/cop/registry.rb

@@ -23,8 +23,8 @@ module RuboCop
         global.without_department(:Test).cops
       end
 
-      def self.qualified_cop_name(name, origin, warn: true)
-        global.qualified_cop_name(name, origin, warn: warn)
+      def self.qualified_cop_name(name, origin, warn: true, correct_namespace: true)
+        global.qualified_cop_name(name, origin, warn: warn, correct_namespace: correct_namespace)
       end
 
       # Changes momentarily the global registry
@@ -171,11 +171,19 @@ module RuboCop
       # @note Emits a warning if the provided name has an incorrect namespace
       #
       # @return [String] Qualified cop name
-      def qualified_cop_name(name, path, warn: true)
+      def qualified_cop_name(name, path, warn: true, correct_namespace: true)
         badge = Badge.parse(name)
         print_department_missing_warning(name, path) if warn && department_missing?(badge, name)
         return name if registered?(badge)
+        # A name qualified with the wrong department is returned as is when
+        # namespace correction is not wanted, so the caller can surface the
+        # mistake instead of silently acting on the corrected name.
+        return name if badge.qualified? && !correct_namespace
 
+        resolve_cop_name(badge, name, path, warn)
+      end
+
+      def resolve_cop_name(badge, name, path, warn)
         potential_badges = qualify_badge(badge)
 
         case potential_badges.size
@@ -272,6 +280,12 @@ module RuboCop
         config.enabled_new_cop?(cop_name)
       end
 
+      # Preview cops are opt-in and stay silent otherwise, so unlike pending cops
+      # they are never reported as needing a decision.
+      def enabled_preview_cop?(cop_cfg, config)
+        cop_cfg.fetch('Enabled') == 'preview' && config.preview?(@options)
+      end
+
       def names
         clear_enrollment_queue
         @cops_by_badge.keys.map(&:to_s)
@@ -325,10 +339,33 @@ module RuboCop
         cop ? [cop] : cops_for_department(directive)
       end
 
+      # Loads all cops that are registered for lazy loading. Useful when lazily registered cops
+      # must not outlive the current global registry, e.g. before a temporary global registry is
+      # discarded in tests.
+      #
+      # @api private
+      def load_all_lazy_cops
+        # Take a snapshot because loading a cop can load (and thereby register)
+        # another lazy-loaded cop, e.g. its superclass.
+        badges = @cops_by_badge.keys
+
+        badges.each do |badge|
+          load_lazy_cop(badge) if @cops_by_badge[badge].is_a?(String)
+        end
+      end
+
       def freeze
         clear_enrollment_queue
         load_all_lazy_cops
         unqualified_cop_names # build cache
+
+        # Freeze the structural collections as well, so that a cop class defined after
+        # the freeze fails fast at its `enlist`/`lazy_load` call site instead of corrupting
+        # the registry and failing much later.
+        @cops_by_badge.freeze
+        @departments.freeze
+        @enrollment_queue.freeze
+
         super
       end
 
@@ -389,7 +426,9 @@ module RuboCop
         # caching which expects cop names or cop classes as keys.
         cfg = config.for_cop(cop_name)
 
-        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config, cop_name)
+        cop_enabled = cfg.fetch('Enabled') == true ||
+                      enabled_pending_cop?(cfg, config, cop_name) ||
+                      enabled_preview_cop?(cfg, config)
 
         if options.fetch(:safe, false)
           cop_enabled && cfg.fetch('Safe', true)
@@ -398,13 +437,6 @@ module RuboCop
         end
       end
 
-      def load_all_lazy_cops
-        # Take a snapshot because loading a cop can load (and thereby register)
-        # another lazy-loaded cop, e.g. its superclass.
-        badges = @cops_by_badge.keys
-        badges.each { |badge| load_lazy_cop(badge) if @cops_by_badge[badge].is_a?(String) }
-      end
-
       # @return [Class, nil] the loaded cop class, or nil if the cop excluded
       #   itself from the registry while being loaded
       def load_lazy_cop(badge)

data/lib/rubocop/cop/severity.rb

@@ -21,6 +21,18 @@ module RuboCop
       #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
+      # The lowest severity that makes a run fail: `--fail-level` when given,
+      # otherwise `AllCops: FailLevel`. `autocorrect` is a pseudo level on the
+      # command line that gates on corrections instead, so it leaves the
+      # threshold at the configured one.
+      def self.minimum_to_fail(options, config)
+        name = options[:fail_level]
+        if name.nil? || name == :autocorrect
+          name = (config&.for_all_cops&.[]('FailLevel') || :refactor).to_sym
+        end
+        new(name)
+      end
+
       def self.name_from_code(code)
         name = code.to_sym
         CODE_TABLE[name] || name