rubocop 1.73.0 → 1.74.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d6b4b7f7dd2a3128259ff94614da64550ae7c4148106a681987a9ee739b905
-  data.tar.gz: 023ed07c7e4445c1dc44b3062cf0199321e3cc7fc6d4abf55287d281519bdb11
+  metadata.gz: 440bee0e28f294bab2eba4c11e9c681342917c69ad4c00e36eceb88743767c29
+  data.tar.gz: 68e9e209a22e891a38b677f97344d2d10e9a8913dd999751472f301deed43b31
 SHA512:
-  metadata.gz: cfc82c25468c882682017c7ab8f750970896dcacae270fc00fc6482e4a7d12a20c97f7f56509811fec8c811981be457fc450c977c058d72700490ae72a4aff0a
-  data.tar.gz: 04cfd985c5527d40ba6fd11e33e64278f37b8fcd78a63cfcdf5fef317bef248bfc8771febfa39a05a474372c1ad56190766dc7a188ea9e17bc72031f16d672da
+  metadata.gz: 70db27a5b7a0e00696672a5b4fcd4e3bf35aa40c85ef65ccb630914ab110a5e5b657927aa1b1c8637be76b7041a90e2ad3c4ed188110266c048d0c4d6a4be0b4
+  data.tar.gz: e5599d30a4f776d85d202acad2ac03c7e4568e64a1c4038cb87b8ee3372b2428882924a91ea49853c98cf0614280d002918363eef41fe0990dc8b1895d8e9776

data/README.md

@@ -52,7 +52,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.73', require: false
+gem 'rubocop', '~> 1.74', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -1887,10 +1887,9 @@ Lint/EmptyConditionalBody:
   Description: 'Checks for the presence of `if`, `elsif` and `unless` branches without a body.'
   Enabled: true
   AutoCorrect: contextual
-  SafeAutoCorrect: false
   AllowComments: true
   VersionAdded: '0.89'
-  VersionChanged: '1.61'
+  VersionChanged: '1.73'
 
 Lint/EmptyEnsure:
   Description: 'Checks for empty ensure block.'
@@ -3105,6 +3104,8 @@ Naming/VariableNumber:
   CheckMethodNames: true
   CheckSymbols: true
   AllowedIdentifiers:
+    - TLS1_1       # OpenSSL::SSL::TLS1_1_VERSION
+    - TLS1_2       # OpenSSL::SSL::TLS1_2_VERSION
     - capture3     # Open3.capture3
     - iso8601      # Time#iso8601
     - rfc1123_date # CGI.rfc1123_date
@@ -3500,6 +3501,7 @@ Style/ClassAndModuleChildren:
   SafeAutoCorrect: false
   Enabled: true
   VersionAdded: '0.19'
+  VersionChanged: '1.74'
   #
   # Basically there are two different styles:
   #
@@ -3515,7 +3517,21 @@ Style/ClassAndModuleChildren:
   #
   # The compact style is only forced, for classes or modules with one child.
   EnforcedStyle: nested
-  SupportedStyles:
+  SupportedStyles: &supported_styles
+    - nested
+    - compact
+  # Configure classes separately, if desired. If not set, or set to `nil`,
+  # the `EnforcedStyle` value will be used.
+  EnforcedStyleForClasses: ~
+  SupportedStylesForClasses:
+    - ~
+    - nested
+    - compact
+  # Configure modules separately, if desired. If not set, or set to `nil`,
+  # the `EnforcedStyle` value will be used.
+  EnforcedStyleForModules: ~
+  SupportedStylesForModules:
+    - ~
     - nested
     - compact
 
@@ -3668,6 +3684,12 @@ Style/CommentedKeyword:
   VersionAdded: '0.51'
   VersionChanged: '1.19'
 
+Style/ComparableBetween:
+  Description: 'Enforces the use of `Comparable#between?` instead of logical comparison.'
+  Enabled: pending
+  VersionAdded: '1.74'
+  StyleGuide: '#ranges-or-between'
+
 Style/ComparableClamp:
   Description: 'Enforces the use of `Comparable#clamp` instead of comparison by minimum and maximum.'
   Enabled: pending
@@ -4070,8 +4092,14 @@ Style/FormatStringToken:
   # style token in a format string to be allowed when enforced style is not
   # `unannotated`.
   MaxUnannotatedPlaceholdersAllowed: 1
+  # The mode the cop operates in. Two values are allowed:
+  # * aggressive (default): all strings are considered
+  # * conservative:
+  #     only register offenses for strings given to `printf`, `sprintf`,
+  #     format` and `%` methods. Other strings are not considered.
+  Mode: aggressive
   VersionAdded: '0.49'
-  VersionChanged: '1.0'
+  VersionChanged: '1.74'
   AllowedMethods: []
   AllowedPatterns: []
 
@@ -5108,6 +5136,9 @@ Style/RedundantCondition:
   Description: 'Checks for unnecessary conditional expressions.'
   Enabled: true
   VersionAdded: '0.76'
+  VersionChanged: '1.73'
+  AllowedMethods:
+    - nonzero?
 
 Style/RedundantConditional:
   Description: "Don't return true/false from a conditional."

data/config/internal_affairs.yml

@@ -14,6 +14,10 @@ InternalAffairs/ExampleDescription:
   Include:
     - 'spec/rubocop/cop/**/*.rb'
 
+InternalAffairs/NodeTypeGroup:
+  Include:
+    - 'lib/rubocop/cop/**/*.rb'
+
 InternalAffairs/OnSendWithoutOnCSend:
   Include:
     - 'lib/rubocop/cop/**/*.rb'

data/lib/rubocop/config_loader.rb

@@ -63,7 +63,6 @@ module RuboCop
         loaded_features = resolver.resolve_requires(path, hash)
         add_loaded_features(loaded_features)
 
-        resolver.override_department_setting_for_cops({}, hash)
         resolver.resolve_inheritance_from_gems(hash)
         resolver.resolve_inheritance(path, hash, file, debug?)
         hash.delete('inherit_from')

data/lib/rubocop/config_loader_resolver.rb

@@ -9,7 +9,8 @@ module RuboCop
   # @api private
   class ConfigLoaderResolver # rubocop:disable Metrics/ClassLength
     def resolve_plugins(rubocop_config, plugins)
-      return if (plugins = Array(plugins)).empty?
+      plugins = Array(plugins) - ConfigLoader.loaded_plugins.map { |plugin| plugin.about.name }
+      return if plugins.empty?
 
       Plugin.integrate_plugins(rubocop_config, plugins)
     end

data/lib/rubocop/config_obsoletion/extracted_cop.rb

@@ -15,7 +15,7 @@ module RuboCop
       end
 
       def violated?
-        return false if feature_loaded?
+        return false if plugin_loaded?
 
         affected_cops.any?
       end
@@ -38,8 +38,9 @@ module RuboCop
         end
       end
 
-      def feature_loaded?
-        config.loaded_features.include?(gem)
+      def plugin_loaded?
+        # Plugins loaded via `require` are included in `loaded_features`.
+        config.loaded_plugins.include?(gem) || config.loaded_features.include?(gem)
       end
     end
   end

data/lib/rubocop/config_obsoletion.rb

@@ -50,7 +50,7 @@ module RuboCop
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
     def load_rules # rubocop:disable Metrics/AbcSize
-      rules = LOAD_RULES_CACHE[self.class.files] ||=
+      rules = LOAD_RULES_CACHE[self.class.files.hash] ||=
         self.class.files.each_with_object({}) do |filename, hash|
           hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
             case first

data/lib/rubocop/cop/internal_affairs/example_description.rb

@@ -50,10 +50,12 @@ module RuboCop
         }.freeze
 
         EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
-          /\A(auto[- ]?)?correct/ => 'does not correct'
+          /\A(auto[- ]?)?corrects?/ => 'does not correct',
+          /\band (auto[- ]?)?corrects/ => 'but does not correct'
         }.freeze
 
         EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\bbut (does not|doesn't) (auto[- ]?)?correct/ => 'and autocorrects',
           /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
         }.freeze
 

data/lib/rubocop/cop/internal_affairs/node_type_group.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node types are checked against their group when all types of a
+      # group are checked.
+      #
+      # @example
+      #   # bad
+      #   node.type?(:irange, :erange)
+      #
+      #   # good
+      #   node.range_type?
+      #
+      #   # bad
+      #   node.type?(:irange, :erange, :send, :csend)
+      #
+      #   # good
+      #   node.type?(:range, :call)
+      #
+      class NodeTypeGroup < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `:%<group>s` instead of individually listing group types.'
+
+        RESTRICT_ON_SEND = %i[type? each_ancestor each_child_node each_descendant each_node].freeze
+
+        def on_send(node)
+          return unless node.receiver
+
+          symbol_args = node.arguments.select(&:sym_type?)
+          return if symbol_args.none?
+
+          NodePatternGroups::NODE_GROUPS.each do |group_name, group_types|
+            next unless group_satisfied?(group_types, symbol_args)
+
+            offense_range = arguments_range(node)
+            add_offense(offense_range, message: format(MSG, group: group_name)) do |corrector|
+              autocorrect(corrector, node, symbol_args, group_name, group_types)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos,
+            node.last_argument.source_range.end_pos
+          )
+        end
+
+        def group_satisfied?(group_types, symbol_args)
+          group_types.all? { |type| symbol_args.any? { |arg| arg.value == type } }
+        end
+
+        def autocorrect(corrector, node, symbol_args, group_name, group_types)
+          if node.method?(:type?) && node.arguments.count == group_types.count
+            autocorrect_to_explicit_predicate(corrector, node, group_name)
+          else
+            autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          end
+        end
+
+        def autocorrect_to_explicit_predicate(corrector, node, group_name)
+          corrector.replace(node.selector, "#{group_name}_type?")
+          corrector.remove(arguments_range(node))
+        end
+
+        def autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          first_replaced = false
+          symbol_args.each do |arg|
+            next unless group_types.include?(arg.value)
+
+            if first_replaced
+              range = range_with_surrounding_space(arg.source_range)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            else
+              first_replaced = true
+              corrector.replace(arg, ":#{group_name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -17,6 +17,7 @@ require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
 require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_group'
 require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -155,10 +155,10 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements.flat_map do |e|
-            if e.hash_type?
-              e.each_child_node.map { |child| child.loc.column }
-            else
+          if elements.first.hash_type?
+            elements.first.each_child_node.map { |child| child.loc.column }
+          else
+            elements.flat_map do |e|
               e.loc.column
             end
           end.uniq.count == 1

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

@@ -7,11 +7,6 @@ module RuboCop
       #
       # NOTE: empty `else` branches are handled by `Style/EmptyElse`.
       #
-      # @safety
-      #   Autocorrection for this cop is not safe. The conditions for empty branches that
-      #   the autocorrection removes may have side effects, or the logic in subsequent
-      #   branches may change due to the removal of a previous condition.
-      #
       # @example
       #   # bad
       #   if condition
@@ -41,6 +36,13 @@ module RuboCop
       #   if condition
       #     do_something
       #   elsif other_condition
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_something
+      #   elsif other_condition
       #     do_something_else
       #   end
       #
@@ -63,11 +65,9 @@ module RuboCop
       class EmptyConditionalBody < Base
         extend AutoCorrector
         include CommentsHelp
-        include RangeHelp
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
@@ -75,12 +75,11 @@ module RuboCop
           range = offense_range(node)
 
           add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
-            next if node.parent&.call_type?
+            next unless can_simplify_conditional?(node)
 
-            autocorrect(corrector, node)
+            flip_orphaned_else(corrector, node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -92,53 +91,23 @@ module RuboCop
           end
         end
 
-        def autocorrect(corrector, node)
-          remove_comments(corrector, node)
-          remove_empty_branch(corrector, node)
-          correct_other_branches(corrector, node)
-        end
-
-        def remove_comments(corrector, node)
-          comments_in_range(node).each do |comment|
-            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
-            corrector.remove(range)
-          end
+        def can_simplify_conditional?(node)
+          node.else_branch && node.loc.else.source == 'else'
         end
 
-        # rubocop:disable Metrics/AbcSize
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
-                  elsif same_line?(node, else_kw_loc = node.loc.else)
-                    node.source_range.begin.join(else_kw_loc.begin)
-                  elsif node.parent&.loc.respond_to?(:end) &&
-                        same_line?(node, end_loc = node.parent.loc.end)
-                    node.source_range.begin.join(end_loc.begin)
                   else
                     deletion_range(branch_range(node))
                   end
 
           corrector.remove(range)
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def correct_other_branches(corrector, node)
-          return unless require_other_branches_correction?(node)
-
-          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
-            # Replace an orphaned `elsif` with `if`
-            corrector.replace(node.else_branch.loc.keyword, 'if')
-          else
-            # Flip orphaned `else`
-            corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
-          end
-        end
-
-        def require_other_branches_correction?(node)
-          return false unless node.if_type? && node.else?
-          return false if !empty_if_branch?(node) && node.elsif?
 
-          !empty_elsif_branch?(node)
+        def flip_orphaned_else(corrector, node)
+          corrector.replace(node.loc.else, "#{node.inverse_keyword} #{node.condition.source}")
+          remove_empty_branch(corrector, node)
         end
 
         def empty_if_branch?(node)
@@ -149,36 +118,17 @@ module RuboCop
           if_branch.if_type? && !if_branch.body
         end
 
-        def empty_elsif_branch?(node)
-          return false unless (else_branch = node.else_branch)
-
-          else_branch.if_type? && !else_branch.body
-        end
-
         def else_branch?(node)
           node.else_branch && !node.else_branch.if_type?
         end
 
-        # rubocop:disable Metrics/AbcSize
         def branch_range(node)
           if empty_if_branch?(node) && else_branch?(node)
             node.source_range.with(end_pos: node.loc.else.begin_pos)
           elsif node.loc.else
             node.source_range.with(end_pos: node.condition.source_range.end_pos)
-          elsif all_branches_body_missing?(node)
-            if_node = node.ancestors.detect(&:if?)
-            node.source_range.join(if_node.loc.end.end)
-          else
-            node.source_range
           end
         end
-        # rubocop:enable Metrics/AbcSize
-
-        def all_branches_body_missing?(node)
-          return false unless node.parent&.if_type?
-
-          node.parent.branches.compact.empty?
-        end
 
         def deletion_range(range)
           # Collect a range between the start of the `if` node and the next relevant node,

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

@@ -156,12 +156,6 @@ module RuboCop
 
           overridden_kwargs
         end
-
-        def arguments_range(node)
-          arguments = node.arguments
-
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -18,12 +18,15 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   if some_var && true
+      #   # We're only interested in the left hand side being a truthy literal,
+      #   # because it affects the evaluation of the &&, whereas the right hand
+      #   # side will be conditionally executed/called and can be a literal.
+      #   if true && some_var
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var && some_condition
+      #   if some_var
       #     do_something
       #   end
       #
@@ -39,23 +42,17 @@ module RuboCop
         MSG = 'Literal `%<literal>s` appeared as a condition.'
         RESTRICT_ON_SEND = [:!].freeze
 
-        # rubocop:disable Metrics/AbcSize
         def on_and(node)
-          if node.lhs.truthy_literal? && node.rhs.truthy_literal?
-            add_offense(node) do |corrector|
-              corrector.replace(node, 'true')
-            end
-          elsif node.lhs.truthy_literal?
-            add_offense(node.lhs) do |corrector|
-              corrector.replace(node, node.rhs.source)
-            end
-          elsif node.rhs.truthy_literal?
-            add_offense(node.rhs) do |corrector|
-              corrector.replace(node, node.lhs.source)
-            end
+          return unless node.lhs.truthy_literal?
+
+          add_offense(node.lhs) do |corrector|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_if(node)
           cond = condition(node)

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

@@ -94,7 +94,7 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type != :literal
+            bound&.type != :literal
           end
         end
 

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

@@ -46,7 +46,7 @@ module RuboCop
         def on_return(return_node)
           return if return_value?(return_node)
 
-          return_node.each_ancestor(:block, :def, :defs) do |node|
+          return_node.each_ancestor(:any_block, :def, :defs) do |node|
             break if scoped_node?(node)
 
             # if a proc is passed to `Module#define_method` or
@@ -54,7 +54,7 @@ module RuboCop
             # non-local exit error
             break if define_method?(node.send_node)
 
-            next unless node.arguments?
+            next if node.argument_list.empty?
 
             if chained_send?(node.send_node)
               add_offense(return_node.loc.keyword)

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_r`, `to_c`,
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_d`, `to_r`, `to_c`,
       # `to_a`, `to_h`, and `to_set`.
       #
       # When one of these methods is called on an object of the same type, that object
       # is returned, making the call unnecessary. The cop detects conversion methods called
       # on object literals, class constructors, class `[]` methods, and the `Kernel` methods
-      # `String()`, `Integer()`, `Float()`, `Rational()`, `Complex()` and `Array()`.
+      # `String()`, `Integer()`, `Float()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
       #
       # Specifically, these cases are detected for each conversion method:
       #
@@ -98,6 +98,7 @@ module RuboCop
           to_s: 'string_constructor?',
           to_i: 'integer_constructor?',
           to_f: 'float_constructor?',
+          to_d: 'bigdecimal_constructor?',
           to_r: 'rational_constructor?',
           to_c: 'complex_constructor?',
           to_a: 'array_constructor?',
@@ -110,7 +111,7 @@ module RuboCop
         TYPED_METHODS = { to_s: %i[inspect] }.freeze
 
         CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
-        RESTRICT_ON_SEND = CONVERSION_METHODS
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
 
         private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
 
@@ -137,6 +138,11 @@ module RuboCop
           #type_constructor?(:Float)
         PATTERN
 
+        # @!method bigdecimal_constructor?(node)
+        def_node_matcher :bigdecimal_constructor?, <<~PATTERN
+          #type_constructor?(:BigDecimal)
+        PATTERN
+
         # @!method rational_constructor?(node)
         def_node_matcher :rational_constructor?, <<~PATTERN
           #type_constructor?(:Rational)

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

@@ -35,22 +35,15 @@ module RuboCop
         def on_return(return_node)
           return unless return_node.descendants.any?
 
-          context_node = non_void_context(return_node)
-
-          return unless context_node&.def_type?
-          return unless context_node&.void_context?
+          def_node = return_node.each_ancestor(:def).first
+          return unless def_node&.void_context?
+          return if return_node.each_ancestor(:any_block).any?(&:lambda?)
 
           add_offense(
             return_node.loc.keyword,
-            message: format(message, method: context_node.method_name)
+            message: format(message, method: def_node.method_name)
           )
         end
-
-        private
-
-        def non_void_context(return_node)
-          return_node.each_ancestor(:block, :def, :defs).first
-        end
       end
     end
   end

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

@@ -51,7 +51,18 @@ module RuboCop
 
         # @!method hash_initialized_with_mutable_shared_object?(node)
         def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
-          (send (const {nil? cbase} :Hash) :new {array hash (send (const {nil? cbase} {:Array :Hash}) :new)})
+          {
+            (send (const {nil? cbase} :Hash) :new [
+              {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
+              !#capacity_keyword_argument?
+            ])
+            (send (const {nil? cbase} :Hash) :new hash #capacity_keyword_argument?)
+          }
+        PATTERN
+
+        # @!method capacity_keyword_argument?(node)
+        def_node_matcher :capacity_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :capacity) _))
         PATTERN
 
         def on_send(node)

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for useless constant scoping. Private constants must be defined using
-      # `private_constant` or `class << self`. Even if `private` access modifier is used,
-      # it is public scope despite its appearance.
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
       #
       # It does not support autocorrection due to behavior change and multiple ways to fix it.
       # Or a public constant may be intended.
@@ -26,14 +26,6 @@ module RuboCop
       #
       #   # good
       #   class Foo
-      #     class << self
-      #       private
-      #       PRIVATE_CONST = 42
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Foo
       #     PUBLIC_CONST = 42 # If private scope is not intended.
       #   end
       #
@@ -46,7 +38,6 @@ module RuboCop
         PATTERN
 
         def on_casgn(node)
-          return if node.each_ancestor(:sclass).any?
           return unless after_private_modifier?(node.left_siblings)
           return if private_constantize?(node.right_siblings, node.name)