rubocop 1.90.0 → 1.92.0

data/lib/rubocop/comment_config.rb

@@ -6,6 +6,7 @@ module RuboCop
   class CommentConfig
     extend SimpleForwardable
     include DisableNext
+    include PushPop
 
     CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
 
@@ -75,20 +76,19 @@ module RuboCop
       non_comment_token_line_numbers.none?(line_number)
     end
 
-    # The names of the cops that are opted in by an `enable` comment directive,
-    # used to mobilize cops disabled in the config on demand.
+    # The names of the cops that are opted in by an `enable` comment directive
+    # or a `+` argument of a `push`/`next` directive, used to mobilize cops
+    # disabled in the config on demand. Departments are expanded for the
+    # opt-in forms only: a plain `enable` naming a department usually just
+    # closes a `disable` of it, and expanding it would switch on every
+    # config-disabled cop of the department for the rest of the file.
     #
     # @api private
     # @return [Set<String>]
     def opt_in_cops
       @opt_in_cops ||= begin
         cops = Set.new
-        each_directive do |directive|
-          next unless directive.enabled?
-          next if directive.all_cops?
-
-          cops.merge(directive.raw_cop_names)
-        end
+        each_directive { |directive| cops.merge(opted_in_by(directive)) }
         cops
       end
     end
@@ -98,9 +98,7 @@ module RuboCop
     def extra_enabled_comments_with_names(extras:, names:)
       each_directive do |directive|
         next unless comment_only_line?(directive.line_number)
-        # Push/pop and next-statement directives close themselves, so they
-        # play no part in the disable/enable pairing.
-        next if directive.push? || directive.pop? || directive.disable_next?
+        next if self_closing_directive?(directive)
 
         if directive.enabled_all?
           handle_enable_all(directive, names, extras)
@@ -112,6 +110,18 @@ module RuboCop
       extras
     end
 
+    def opted_in_by(directive)
+      if directive.push? || directive.next?
+        directive.signed_args.fetch('+', []).flat_map { |name| expand_cop_name(name) }
+      elsif !directive.enabled? || directive.all_cops?
+        []
+      elsif directive.enable_next?
+        directive.cop_names
+      else
+        directive.raw_cop_names
+      end
+    end
+
     # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     def analyze
       return {} if @no_directives
@@ -128,6 +138,10 @@ module RuboCop
           pop_state(analyses, directive.line_number) if @stack.any?
         elsif directive.disable_next?
           apply_disable_next(analyses, directive)
+        elsif directive.next?
+          apply_next_directive(analyses, resolve_push_cops(directive), directive)
+        elsif directive.enable_next?
+          apply_enable_next(analyses, directive)
         else
           directive.cop_names.each do |cop_name|
             cop_name = qualified_cop_name(cop_name)
@@ -144,48 +158,6 @@ module RuboCop
       end
     end
 
-    def resolve_push_cops(directive)
-      directive.push_args.transform_values do |names|
-        names.flat_map { |name| expand_cop_name(name) }
-      end
-    end
-
-    def expand_cop_name(name)
-      registry = Cop::Registry.global
-      cops = registry.department?(name) ? registry.names_for_department(name) : [name]
-      cops.map { |c| qualified_cop_name(c) }
-    end
-
-    def apply_push(analyses, resolved_cops, directive)
-      resolved_cops.each do |op, cops|
-        cops.each { |cop| apply_cop_op(analyses, op, cop, directive) }
-      end
-    end
-
-    def apply_cop_op(analyses, operation, cop, directive)
-      analysis = analyses[cop]
-      line = directive.line_number
-      if operation == '-' && !analysis.start_line_number
-        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line, directive)
-      elsif operation == '+' && analysis.start_line_number
-        analyses[cop] = CopAnalysis.new(analysis.close(line), nil)
-      end
-    end
-
-    def pop_state(analyses, line)
-      restore_point = @stack.pop
-      (restore_point.keys | analyses.keys).each do |cop|
-        analyses[cop] = popped_analysis(analyses[cop], restore_point[cop], line)
-      end
-    end
-
-    def popped_analysis(current, restored, line)
-      ranges = current.close(line - 1)
-      return CopAnalysis.new(ranges, nil) unless restored&.start_line_number
-
-      CopAnalysis.new(ranges, line, restored.start_directive)
-    end
-
     def inject_disabled_cops_directives(analyses)
       registry.disabled_names(config).each do |cop_name|
         analyses[cop_name] = analyze_cop(
@@ -236,6 +208,13 @@ module RuboCop
       end
     end
 
+    # Push/pop and next-statement directives close themselves, so they
+    # play no part in the disable/enable pairing.
+    def self_closing_directive?(directive)
+      directive.push? || directive.pop? || directive.disable_next? ||
+        directive.next? || directive.enable_next?
+    end
+
     def qualified_cop_name(cop_name)
       # A directive naming a cop under the wrong department is not honored -
       # the mistake is surfaced by `Lint/RedundantCopDisableDirective` (with a

data/lib/rubocop/config.rb

@@ -226,6 +226,16 @@ module RuboCop
       end
     end
 
+    # Whether preview behavior is on, for cops that gate an unstable change
+    # behind it and for cops that are themselves `Enabled: preview`.
+    # `--preview` / `--no-preview` win over `AllCops: Preview`.
+    def preview?(options = {})
+      preview = options[:preview]
+      return preview unless preview.nil?
+
+      for_all_cops['Preview'] == true
+    end
+
     def active_support_extensions_enabled?
       for_all_cops['ActiveSupportExtensionsEnabled']
     end

data/lib/rubocop/config_loader.rb

@@ -24,7 +24,8 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops
+                    :enabled_by_default, :disabled_by_default, :ignore_unrecognized_cops,
+                    :preview
       attr_writer :default_configuration, :cache_root
       attr_reader :loaded_plugins, :loaded_features
 
@@ -41,6 +42,7 @@ module RuboCop
         @loaded_features = Set.new
         @disable_pending_cops = nil
         @enable_pending_cops = nil
+        @preview = nil
         @enabled_by_default = nil
         @disabled_by_default = nil
         @ignore_parent_exclusion = nil
@@ -171,7 +173,8 @@ module RuboCop
         hash = ConfigLoader.load_yaml_configuration(path)
         config = Config.new(hash, path).tap(&:make_excludes_absolute)
 
-        @default_configuration = ConfigLoader.merge_with_default(config, path)
+        @default_configuration =
+          ConfigLoader.merge_with_default(config, path, resolve_preview: false)
       end
 
       # Returns the path RuboCop inferred as the root of the project. No file
@@ -187,20 +190,28 @@ module RuboCop
       end
 
       # Merges the given configuration with the default one.
-      def merge_with_default(config, config_file, unset_nil: true)
-        resolver.merge_with_default(config, config_file, unset_nil: unset_nil)
+      def merge_with_default(config, config_file, unset_nil: true, resolve_preview: true)
+        resolver.merge_with_default(
+          config, config_file, unset_nil: unset_nil, resolve_preview: resolve_preview
+        )
       end
 
       # Applies CLI overrides for `AllCops/EnabledByDefault` and
       # `AllCops/DisabledByDefault` to the given configuration. Used when the
       # configuration would otherwise be returned without going through
       # `merge_with_default` (e.g. there is no user-supplied `.rubocop.yml`).
+      # Used when there is no configuration file, so the defaults are the whole
+      # configuration and still need the same treatment `merge_with_default`
+      # would have given them.
       def apply_default_overrides(config)
-        return config if @enabled_by_default.nil? && @disabled_by_default.nil?
+        hash = resolver.apply_preview_defaults(config, preview == true)
 
-        hash = config.transform_values do |params|
-          params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+        unless @enabled_by_default.nil? && @disabled_by_default.nil?
+          hash = hash.transform_values do |params|
+            params.is_a?(Hash) ? params.merge('Enabled' => !@disabled_by_default) : params
+          end
         end
+
         Config.new(hash, config.loaded_path)
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -37,8 +37,9 @@ module RuboCop
 
     def resolve_inheritance(path, hash, file, debug) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       inherited_files = Array(hash['inherit_from'])
-      base_configs(path, inherited_files, file)
-        .each_with_index.reverse_each do |base_config, index|
+      base_configs = base_configs(path, inherited_files, file)
+      preview = inherited_preview?(hash, base_configs)
+      base_configs.each_with_index.reverse_each do |base_config, index|
         override_department_setting_for_cops(base_config, hash)
         override_enabled_for_disabled_departments(base_config, hash)
 
@@ -50,7 +51,7 @@ module RuboCop
             v = merge(v, hash[k],
                       cop_name: k, file: file, debug: debug,
                       inherited_file: inherited_files[index],
-                      inherit_mode: determine_inherit_mode(hash, k))
+                      inherit_mode: determine_inherit_mode(hash, k, preview))
           end
           hash[k] = v
           fix_include_paths(base_config.loaded_path, hash, path, k, v) if only_base_has_include
@@ -94,20 +95,28 @@ module RuboCop
     # only cops explicitly disabled in user configuration are disabled.
     # When the `--disable-all-cops` or `--enable-all-cops` CLI option is given,
     # it takes precedence over the configuration values.
-    def merge_with_default(config, config_file, unset_nil:)
-      default_configuration = ConfigLoader.default_configuration
+    #
+    # With `resolve_preview: false` the `Preview` sections of the default
+    # configuration are left in place and preview is treated as off. That is
+    # what extending the default configuration itself needs: preview gets
+    # applied later, when a project configuration is resolved against it.
+    def merge_with_default(config, config_file, unset_nil:, resolve_preview: true)
+      base_defaults, preview = defaults_with_preview(config, resolve_preview)
+      default_configuration = base_defaults
       disabled_by_default, enabled_by_default = resolve_default_overrides(config)
 
       if disabled_by_default || enabled_by_default
-        default_configuration = transform(default_configuration) do |params|
+        default_configuration = transform(base_defaults) do |params|
           params.merge('Enabled' => !disabled_by_default)
         end
       end
 
-      config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
+      if disabled_by_default
+        config = handle_disabled_by_default(config, default_configuration, base_defaults)
+      end
       override_enabled_for_disabled_departments(default_configuration, config)
 
-      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
+      opts = { inherit_mode: inherit_mode_for_default(config, preview), unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
@@ -166,8 +175,55 @@ module RuboCop
       end
     end
 
+    # A cop's entry in the default configuration may carry a `Preview` section
+    # with the defaults it is expected to adopt in the next major release. Under
+    # `Preview` those replace the current defaults. The section is dropped either
+    # way, so the resolved configuration only ever shows what is in effect.
+    def apply_preview_defaults(default_configuration, preview)
+      transform(default_configuration) do |params|
+        next params unless params['Preview'].is_a?(Hash)
+
+        params = params.dup
+        preview_params = params.delete('Preview')
+        preview ? params.merge(preview_params) : params
+      end
+    end
+
     private
 
+    def defaults_with_preview(config, resolve_preview)
+      defaults = ConfigLoader.default_configuration
+      return [defaults, false] unless resolve_preview
+
+      preview = preview?(config)
+      [apply_preview_defaults(defaults, preview), preview]
+    end
+
+    def inherit_mode_for_default(config, preview)
+      with_preview_exclude_merge(config['inherit_mode'] || {}, preview)
+    end
+
+    # Under `Preview`, `Exclude` is merged rather than replaced, so that excluding
+    # one directory does not silently drop the excludes it would have inherited -
+    # from the default configuration or from a file named in `inherit_from`. An
+    # explicit `inherit_mode` still wins, in either direction.
+    def with_preview_exclude_merge(mode, preview)
+      return mode unless preview
+      return mode if Array(mode['override']).include?('Exclude')
+      return mode if Array(mode['merge']).include?('Exclude')
+
+      mode.merge('merge' => Array(mode['merge']) + ['Exclude'])
+    end
+
+    # `config` has already been through `handle_disabled_by_default` by this
+    # point, which returns a plain hash, so read `AllCops` directly rather than
+    # going through `Config#for_all_cops`.
+    def preview?(config)
+      return ConfigLoader.preview unless ConfigLoader.preview.nil?
+
+      (config['AllCops'] || {})['Preview'] == true
+    end
+
     def resolve_default_overrides(config)
       if ConfigLoader.disabled_by_default || ConfigLoader.enabled_by_default
         [ConfigLoader.disabled_by_default, ConfigLoader.enabled_by_default]
@@ -207,10 +263,21 @@ module RuboCop
         "the same parameter in #{opts[:inherited_file]}"
     end
 
-    def determine_inherit_mode(hash, key)
+    # The `AllCops: Preview` in effect once inheritance is resolved: the file
+    # itself wins, then the files it inherits from, last one first. It has to be
+    # known before merging, since the keys are merged in whatever order they
+    # appear and `AllCops` may well come after the cops whose `Exclude` it affects.
+    def inherited_preview?(hash, base_configs)
+      all_cops = [hash, *base_configs.reverse].map { |config| config['AllCops'] }.find do |params|
+        params.is_a?(Hash) && params.key?('Preview')
+      end
+      preview?('AllCops' => all_cops)
+    end
+
+    def determine_inherit_mode(hash, key, preview)
       cop_cfg = hash[key]
       local_inherit = cop_cfg['inherit_mode'] if cop_cfg.is_a?(Hash)
-      local_inherit || hash['inherit_mode'] || {}
+      with_preview_exclude_merge(local_inherit || hash['inherit_mode'] || {}, preview)
     end
 
     def should_union?(derived_hash, base_hash, root_mode, key)
@@ -276,7 +343,7 @@ module RuboCop
       file.is_a?(RemoteConfig)
     end
 
-    def handle_disabled_by_default(config, new_default_configuration)
+    def handle_disabled_by_default(config, new_default_configuration, base_defaults)
       department_config = config.to_hash.reject { |cop| cop.include?('/') }
       department_config.each do |dept, dept_params|
         next unless dept_params['Enabled']
@@ -285,7 +352,7 @@ module RuboCop
           next unless cop.start_with?("#{dept}/")
 
           # Retain original default configuration for cops in the department.
-          params['Enabled'] = ConfigLoader.default_configuration[cop]['Enabled']
+          params['Enabled'] = base_defaults[cop]['Enabled']
         end
       end
 

data/lib/rubocop/config_obsoletion/cop_rule.rb

@@ -20,7 +20,8 @@ module RuboCop
         rule_message + "\n(obsolete configuration found in #{smart_loaded_path}, please update it)"
       end
 
-      # Cop rules currently can only be failures, not warnings
+      # Failure by default; rules that accept `severity: warning` say so
+      # themselves.
       def warning?
         false
       end

data/lib/rubocop/config_obsoletion/removed_cop.rb

@@ -20,15 +20,23 @@ module RuboCop
 
         if reason
           "#{base} since #{reason.chomp}."
-        elsif alternatives
+        elsif alternatives.any?
           "#{base}. Please use #{to_sentence(alternatives, connector: 'and/or')} instead."
         else
           "#{base}."
         end
       end
 
+      def warning?
+        severity == 'warning'
+      end
+
       private
 
+      def severity
+        metadata['severity']
+      end
+
       def reason
         metadata['reason']
       end

data/lib/rubocop/config_obsoletion.rb

@@ -15,7 +15,7 @@ module RuboCop
       'changed_parameters' => ChangedParameter,
       'changed_enforced_styles' => ChangedEnforcedStyles
     }.freeze
-    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant
+    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
     private_constant :LOAD_RULES_CACHE
 
     attr_reader :rules, :warnings

data/lib/rubocop/config_validator.rb

@@ -11,7 +11,7 @@ module RuboCop
     COMMON_PARAMS = %w[Exclude Include Severity inherit_mode AutoCorrect StyleGuide Details
                        Enabled Reference References Safe SafeAutoCorrect].freeze
     # @api private
-    INTERNAL_PARAMS = %w[Description StyleGuide
+    INTERNAL_PARAMS = %w[Description StyleGuide Preview
                          VersionAdded VersionChanged VersionRemoved
                          Reference References Safe SafeAutoCorrect].freeze
     # @api private
@@ -21,7 +21,7 @@ module RuboCop
 
     # @api private
     CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect References].to_set.freeze
-    CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    CONFIG_CHECK_DEPARTMENTS = %w[pending preview override_department].freeze
     CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
 
@@ -48,7 +48,7 @@ module RuboCop
 
       check_obsoletions
       alert_about_unrecognized_cops(invalid_cop_names)
-      validate_new_cops_parameter
+      validate_all_cops_parameters
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
       validate_syntax_cop
@@ -170,6 +170,32 @@ module RuboCop
       validate_department_new_cops_parameters
     end
 
+    def validate_all_cops_parameters
+      validate_new_cops_parameter
+      validate_fail_level_parameter
+      validate_preview_parameter
+    end
+
+    def validate_fail_level_parameter
+      fail_level = @config.for_all_cops['FailLevel']
+      return if fail_level.nil? || Cop::Severity::NAMES.include?(fail_level.to_sym)
+
+      message = "invalid #{fail_level} for `FailLevel` found in #{smart_loaded_path}\n" \
+                "Valid choices are: #{Cop::Severity::NAMES.join(', ')}"
+
+      raise ValidationError, message
+    end
+
+    def validate_preview_parameter
+      preview = @config.for_all_cops['Preview']
+      return if [nil, true, false].include?(preview)
+
+      message = "invalid #{preview} for `Preview` found in #{smart_loaded_path}\n" \
+                'Valid choices are: true, false'
+
+      raise ValidationError, message
+    end
+
     def validate_all_cops_new_cops_parameter
       new_cop_parameter = @config.for_all_cops['NewCops']
       return if new_cop_parameter.nil? || NEW_COPS_VALUES.include?(new_cop_parameter)

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -40,12 +40,9 @@ module RuboCop
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
 
-        # `false` is the same as `disabled` for backward compatibility.
-        return false if ['disabled', false].include?(cop_config['AutoCorrect'])
+        return false if disabled_autocorrect?
 
-        # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
-        # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
-        return false if contextual_autocorrect? && LSP.enabled?
+        return false if contextual_autocorrect_held_back?
 
         # :safe_autocorrect is a derived option based on several command-line
         # arguments - see RuboCop::Options#add_autocorrection_options
@@ -56,6 +53,14 @@ module RuboCop
 
       private
 
+      # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing
+      # source code, and autocorrection with `AutoCorrect: contextual` will not be performed.
+      # The `editing` option says the same without the rest of LSP mode, which
+      # is about showing offenses in an editor.
+      def contextual_autocorrect_held_back?
+        contextual_autocorrect? && (LSP.enabled? || @options.fetch(:editing, false))
+      end
+
       def disable_offense(offense_range)
         unbreakable_range = multiline_ranges(offense_range)&.find do |range|
           offense_range.overlaps?(range) &&

data/lib/rubocop/cop/badge.rb

@@ -45,7 +45,7 @@ module RuboCop
 
       def hash
         # Do hashing manually to reduce Array allocations.
-        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash
+        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash -- hashing manually avoids the Array allocation
       end
 
       def match?(other)

data/lib/rubocop/cop/base.rb

@@ -49,7 +49,12 @@ module RuboCop
       InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
 
       # List of methods names to restrict calls for `on_send` / `on_csend`
-      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend
+      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend -- the base class default, which cops override
+
+      # Departments whose cops report above `convention` unless a cop says
+      # otherwise. The exceptions live in `config/default.yml` as an explicit
+      # `Severity`, such as the lint-like cops in `Bundler` and `Gemspec`.
+      DEPARTMENT_SEVERITIES = { Lint: :warning, Security: :warning, Metrics: :refactor }.freeze
 
       # List of cops that should not try to autocorrect at the same
       # time as this cop
@@ -211,14 +216,8 @@ module RuboCop
         message = find_message(range_to_pass, message)
 
         status, corrector = enabled_lines?(range) ? correct(range, &block) : :disabled
-        justification = suppression_reason(range) if status == :disabled
-
-        # Since this range may be generated from Ruby code embedded in some
-        # template file, we convert it to location info in the original file.
-        range = range_for_original(range)
 
-        current_offenses << Offense.new(severity, range, message, name, status, corrector,
-                                        justification: justification)
+        current_offenses << new_offense(range, severity, message, status, corrector)
       end
 
       # This method should be overridden when a cop's behavior depends
@@ -266,10 +265,21 @@ module RuboCop
         @config.target_ruby_version
       end
 
-      # Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked)
-      # @returns [Gem::Version | nil] The locked gem version, or nil if the gem is not present.
+      # Returns the version of a gem in the target, by default its locked version
+      # (i.e. from Gemfile.lock or gems.locked).
+      #
+      # The requirements declared with `requires_gem` are checked against the version
+      # this method returns, so an extension that lets users state the version of its
+      # gem in `AllCops` (e.g. `TargetFrameworkVersion`) can override it for that gem,
+      # returning a `Gem::Version`, and fall back to `super` for any other gem.
+      #
+      # @param [String] gem_name
+      # @return [Gem::Version, nil] The gem version, or nil if the gem is not present.
+      #
+      # @api public
       def target_gem_version(gem_name)
-        @config.gem_versions_in_target && @config.gem_versions_in_target[gem_name]
+        gem_versions = @config.gem_versions_in_target
+        gem_versions && gem_versions[gem_name]
       end
 
       def parser_engine
@@ -288,6 +298,13 @@ module RuboCop
         @config.string_literals_frozen_by_default?
       end
 
+      # Whether the user opted in to unstable behavior, with `--preview` or
+      # `AllCops: Preview`. Cops branch on this to ship a change that is not
+      # ready to be the default yet.
+      def preview?
+        @config.preview?(@options)
+      end
+
       def relevant_file?(file)
         return false unless target_satisfies_all_gem_version_requirements?
         return true unless @config.clusivity_config_for_badge?(self.class.badge)
@@ -326,7 +343,7 @@ module RuboCop
 
       ### Reserved for Commissioner
 
-      # rubocop:disable Layout/ClassStructure
+      # rubocop:disable Layout/ClassStructure -- grouped under the Commissioner heading above
       # @api private
       def callbacks_needed
         self.class.callbacks_needed
@@ -370,6 +387,12 @@ module RuboCop
         cop_config.fetch('AutoCorrect', 'always') == 'contextual'
       end
 
+      # @api private
+      def disabled_autocorrect?
+        # `false` is the same as `'disabled'` for backward compatibility.
+        ['disabled', false].include?(cop_config['AutoCorrect'])
+      end
+
       def inspect # :nodoc:
         "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
       end
@@ -382,6 +405,22 @@ module RuboCop
         @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
       end
 
+      # @return [Offense]
+      def new_offense(range, severity, message, status, corrector)
+        justification = suppression_reason(range) if status == :disabled
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        # A cop configured with `AutoCorrect: false` reports no edits, since
+        # nothing that honors the configuration applies them. The corrector
+        # stays, so an editor can still offer it as a quick fix to choose.
+        corrections = [] if corrector && disabled_autocorrect?
+
+        Offense.new(severity, range_for_original(range), message, name, status, corrector,
+                    justification: justification, correction_safe: safe_autocorrect?,
+                    corrections: corrections)
+      end
+
       ### Reserved for Cop::Cop
 
       def callback_argument(range)
@@ -453,7 +492,8 @@ module RuboCop
           # The unsafe correction will not run, so the offense is
           # uncorrectable for this run and gets a todo comment.
           attempt_correction(range, nil)
-        elsif corrector && (always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?))
+        elsif corrector && (always_autocorrect? ||
+                            (contextual_autocorrect? && !contextual_autocorrect_held_back?))
           :uncorrected
         else
           :unsupported
@@ -561,7 +601,7 @@ module RuboCop
       end
 
       def default_severity
-        self.class.lint? ? :warning : :convention
+        DEPARTMENT_SEVERITIES.fetch(self.class.department, :convention)
       end
 
       def custom_severity
@@ -589,17 +629,10 @@ module RuboCop
       end
 
       def target_satisfies_all_gem_version_requirements?
-        gem_requirements = self.class.gem_requirements
-        return true if gem_requirements.empty?
-
-        gem_requirements.all? do |gem_name, version_req|
-          all_gem_versions_in_target = @config.gem_versions_in_target
-          next false unless all_gem_versions_in_target
-
-          gem_version_in_target = all_gem_versions_in_target[gem_name]
-          next false unless gem_version_in_target
+        self.class.gem_requirements.all? do |gem_name, version_requirement|
+          gem_version = target_gem_version(gem_name)
 
-          version_req.satisfied_by?(gem_version_in_target)
+          gem_version && version_requirement.satisfied_by?(gem_version)
         end
       end
     end

data/lib/rubocop/cop/bundler/gem_comment.rb

@@ -81,7 +81,6 @@ module RuboCop
       #   gem 'bar', '< 2.1'
       #
       class GemComment < Base
-        include DefNode
         include GemDeclaration
 
         MSG = 'Missing gem description comment.'