rubocop 1.71.1 → 1.92.0

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      module Utils
+        # Utility class that checks if the receiver can't be nil.
+        class NilReceiverChecker
+          NIL_METHODS = (nil.methods + %i[!]).to_set.freeze
+
+          def initialize(receiver, additional_nil_methods)
+            @receiver = receiver
+            @additional_nil_methods = additional_nil_methods
+            @checked_nodes = {}.compare_by_identity
+            @receiver_binding_name = binding_name(receiver)
+            @receiver_binding_scope = binding_scope(receiver) if @receiver_binding_name
+          end
+
+          def cant_be_nil?
+            sole_condition_of_parent_if?(@receiver) || _cant_be_nil?(@receiver.parent, @receiver)
+          end
+
+          private
+
+          # rubocop:disable-next Metrics
+          def _cant_be_nil?(node, receiver)
+            return false unless node
+
+            # For some nodes, we check their parent and then some children for these parents.
+            # This is added to avoid infinite loops.
+            return false if @checked_nodes.key?(node)
+
+            @checked_nodes[node] = true
+
+            case node.type
+            when :def, :defs, :class, :module, :sclass
+              return false
+            when :send
+              if node.receiver == receiver && same_binding_as_receiver?(node.receiver)
+                return non_nil_method?(node.method_name)
+              end
+
+              node.arguments.each do |argument|
+                return true if _cant_be_nil?(argument, receiver)
+              end
+
+              return true if _cant_be_nil?(node.receiver, receiver)
+            when :begin
+              return true if _cant_be_nil?(node.children.first, receiver)
+            when :if, :case
+              return true if _cant_be_nil?(node.condition, receiver)
+            when :and, :or
+              return true if _cant_be_nil?(node.lhs, receiver)
+            when :pair
+              if _cant_be_nil?(node.key, receiver) ||
+                 _cant_be_nil?(node.value, receiver)
+                return true
+              end
+            when :when
+              node.conditions.each do |condition|
+                return true if _cant_be_nil?(condition, receiver)
+              end
+            when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              return true if _cant_be_nil?(node.expression, receiver)
+            end
+
+            if sequentially_reached?(node)
+              node.left_siblings.reverse_each do |sibling|
+                next unless sibling.is_a?(AST::Node)
+
+                return true if _cant_be_nil?(sibling, receiver)
+              end
+            end
+
+            if node.parent
+              _cant_be_nil?(node.parent, receiver)
+            else
+              false
+            end
+          end
+
+          def non_nil_method?(method_name)
+            !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
+          end
+
+          # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          def sole_condition_of_parent_if?(node)
+            child = node
+            parent = node.parent
+
+            while parent
+              if parent.if_type?
+                unless parent.unless?
+                  condition = parent.condition
+                  return true if !child.equal?(condition) && non_nil_condition?(condition, node)
+                end
+
+                parent = find_top_if(parent) if parent.elsif?
+              elsif else_branch?(parent)
+                # Find the top `if` for `else`.
+                parent = parent.parent
+              end
+
+              child = parent
+              parent = parent&.parent
+            end
+
+            false
+          end
+
+          def non_nil_condition?(condition, node)
+            return true if condition == node && same_binding_as_receiver?(condition)
+            return false unless condition.csend_type?
+
+            root_receiver = csend_root_receiver(condition)
+
+            root_receiver == node && same_binding_as_receiver?(root_receiver)
+          end
+
+          # Structurally equal occurrences can be different variables: `it` binds to
+          # its innermost block, and a block parameter can shadow an outer variable of
+          # the same name. Evidence about such a receiver only holds when both occurrences
+          # resolve to the same binding.
+          def same_binding_as_receiver?(occurrence)
+            return true unless @receiver_binding_name
+
+            binding_scope(occurrence).equal?(@receiver_binding_scope)
+          end
+
+          # The name whose binding can differ between structurally equal occurrences:
+          # a local variable (block parameters included), or a bare `it` call, which is
+          # how `it` parses when the target Ruby version is below 3.4 even though the code
+          # may run on 3.4+ where `it` is the implicit block parameter.
+          def binding_name(node)
+            if node.lvar_type?
+              node.children.first
+            elsif node.send_type? && !node.receiver && node.method?(:it) && node.arguments.empty?
+              :it
+            end
+          end
+
+          def binding_scope(occurrence)
+            node = occurrence
+
+            while (parent = node.parent)
+              case parent.type
+              when :block, :numblock, :itblock
+                # Only the body is inside the block's scope; the send node and the arguments of
+                # the block node evaluate in the outer scope.
+                return parent if parent.body.equal?(node) && block_binds_name?(parent)
+              when :def, :defs, :class, :module, :sclass
+                return parent
+              end
+
+              node = parent
+            end
+
+            nil
+          end
+
+          def block_binds_name?(block_node)
+            name = @receiver_binding_name
+
+            return true if block_node.argument_list.any? { |argument| argument.name == name }
+
+            name == :it && block_node.arguments.empty?
+          end
+
+          # Whether control reaches `node` by falling through its left siblings rather than by
+          # a non-sequential entry. A `resbody` is entered via an exception, the `ensure` branch
+          # runs even after a partway raise, and the `else` arm of an `if/elsif` chain is reached by
+          # branching (its `if/case` siblings are walked via parent recursion instead).
+          def sequentially_reached?(node)
+            return false if node.resbody_type?
+            return false if node.parent&.ensure_type? && node.parent.branch.equal?(node)
+
+            !else_branch?(node) || (node.if_type? && !node.elsif?)
+          end
+
+          def else_branch?(node)
+            node.parent&.if_type? && node.parent.else_branch == node
+          end
+
+          def find_top_if(node)
+            node = node.parent while node.elsif?
+
+            node
+          end
+
+          def csend_root_receiver(node)
+            return unless (receiver = node.receiver)
+
+            receiver = receiver.receiver while receiver.call_type? && receiver.receiver
+
+            receiver
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,15 @@ module RuboCop
       # enumerator.each { |item| item >= 2 } #=> [2, 3]
       # ----
       #
+      # NOTE: The last expression in an assignment method definition such as `def foo=(arg)`
+      # is not flagged. Ruby discards it (the method returns its argument), but the method can
+      # still be called directly and its return value relied upon, so flagging it would be a
+      # false positive for this lint.
+      #
+      # NOTE: A constant used in a void context is flagged but not autocorrected, since
+      # referencing a constant can trigger autoloading side effects (e.g. forcing a file to
+      # load before a monkey-patch), so removing it may change behavior.
+      #
       # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
       #   def some_method
@@ -81,11 +90,13 @@ module RuboCop
         def on_block(node)
           return unless node.body && !node.body.begin_type?
           return unless in_void_context?(node.body)
+          return if node.method?(:each)
 
-          check_void_op(node.body) { node.method?(:each) }
+          check_void_op(node.body)
           check_expression(node.body)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_begin(node)
           check_begin(node)
@@ -100,22 +111,23 @@ module RuboCop
 
         def check_begin(node)
           expressions = *node
-          expressions.pop unless in_void_context?(node)
+          inside_each_block = node.each_ancestor(:any_block).first&.method?(:each)
+          expressions.pop if !in_void_context?(node) || inside_each_block || setter_method?(node)
           expressions.each do |expr|
-            check_void_op(expr) do
-              block_node = node.each_ancestor(:block).first
-
-              block_node&.method?(:each)
-            end
-
+            check_void_op(expr) { inside_each_block }
             check_expression(expr)
           end
         end
 
         def check_expression(expr)
-          expr = expr.body if expr.if_type?
-          return unless expr
+          return check_if_expression(expr) if expr.if_type?
+          return check_case_expression(expr) if expr.case_type?
+          return check_case_match_expression(expr) if expr.case_match_type?
+
+          check_void_expression_nodes(expr)
+        end
 
+        def check_void_expression_nodes(expr)
           check_literal(expr)
           check_var(expr)
           check_self(expr)
@@ -125,9 +137,30 @@ module RuboCop
           check_nonmutating(expr)
         end
 
+        def check_if_expression(if_node)
+          check_void_expression_nodes(if_node.body) if if_node.body
+        end
+
+        def check_case_expression(case_node)
+          case_node.each_when { |when_node| check_expression(when_node.body) if when_node.body }
+          check_expression(case_node.else_branch) if case_node.else_branch
+        end
+
+        def check_case_match_expression(case_node)
+          case_node.each_in_pattern do |in_pattern_node|
+            check_expression(in_pattern_node.body) if in_pattern_node.body
+          end
+          check_expression(case_node.else_branch) if case_node.else_branch
+        end
+
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
-          node = node.children.first while node.begin_type?
-          return unless node.call_type? && OPERATORS.include?(node.method_name)
+          node = node.children.first while node&.begin_type?
+          return unless node&.call_type? && OPERATORS.include?(node.method_name)
+          if !UNARY_OPERATORS.include?(node.method_name) && node.loc.dot && node.arguments.none?
+            return
+          end
+
           return if block && yield(node)
 
           add_offense(node.loc.selector,
@@ -155,7 +188,9 @@ module RuboCop
         end
 
         def check_literal(node)
-          return if !entirely_literal?(node) || node.xstr_type? || node.range_type?
+          if !entirely_literal?(node) || node.xstr_type? || node.range_type? || node.nil_type?
+            return
+          end
 
           add_offense(node, message: format(LIT_MSG, lit: node.source)) do |corrector|
             autocorrect_void_expression(corrector, node)
@@ -179,7 +214,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return unless node.type?(:send, :any_block)
+          return unless node.type?(:call, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -201,11 +236,6 @@ module RuboCop
           # NOTE: the `begin` node case is already handled via `on_begin`
           return if body.begin_type?
 
-          check_void_op(body) do
-            block_node = node.each_ancestor(:block).first
-            block_node&.method?(:each)
-          end
-
           check_expression(body)
         end
 
@@ -216,6 +246,10 @@ module RuboCop
           parent.respond_to?(:void_context?) && parent.void_context?
         end
 
+        def setter_method?(node)
+          node.parent&.any_def_type? && node.parent.assignment_method?
+        end
+
         def autocorrect_void_op(corrector, node)
           if node.arguments.empty?
             corrector.replace(node, node.receiver.source)
@@ -230,13 +264,25 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
-          return if node.parent.if_type?
+          # Referencing a constant can trigger autoloading side effects (e.g. forcing a file
+          # to load before a monkey-patch), so removing it may change behavior. Flag but don't
+          # autocorrect, leaving it to the user.
+          return if node.const_type? && !node.special_keyword?
+          return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
+          return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
+
+          range = range_with_surrounding_space(range: void_expression_range(node), side: :left)
+          corrector.remove(range)
+        end
+
+        def void_expression_range(node)
+          return node.source_range unless node.respond_to?(:heredoc?) && node.heredoc?
 
-          corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
+          node.source_range.join(node.loc.heredoc_end)
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)
-          send_node = if node.send_type?
+          send_node = if node.call_type?
                         node
                       else
                         node.send_node

data/lib/rubocop/cop/lint.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Lint` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Lint
+      extend LazyLoader
+
+      register_cop :AmbiguousAssignment, "#{__dir__}/lint/ambiguous_assignment"
+      register_cop :AmbiguousBlockAssociation, "#{__dir__}/lint/ambiguous_block_association"
+      register_cop :AmbiguousOperator, "#{__dir__}/lint/ambiguous_operator"
+      register_cop :AmbiguousOperatorPrecedence, "#{__dir__}/lint/ambiguous_operator_precedence"
+      register_cop :AmbiguousRange, "#{__dir__}/lint/ambiguous_range"
+      register_cop :AmbiguousRegexpLiteral, "#{__dir__}/lint/ambiguous_regexp_literal"
+      register_cop :ArgumentMismatch, "#{__dir__}/lint/argument_mismatch"
+      register_cop :ArrayLiteralInRegexp, "#{__dir__}/lint/array_literal_in_regexp"
+      register_cop :AssignmentInCondition, "#{__dir__}/lint/assignment_in_condition"
+      register_cop :BigDecimalNew, "#{__dir__}/lint/big_decimal_new"
+      register_cop :BinaryOperatorWithIdenticalOperands, "#{__dir__}/lint/binary_operator_with_identical_operands"
+      register_cop :BooleanSymbol, "#{__dir__}/lint/boolean_symbol"
+      register_cop :CircularArgumentReference, "#{__dir__}/lint/circular_argument_reference"
+      register_cop :ConstantDefinitionInBlock, "#{__dir__}/lint/constant_definition_in_block"
+      register_cop :ConstantOverwrittenInRescue, "#{__dir__}/lint/constant_overwritten_in_rescue"
+      register_cop :ConstantReassignment, "#{__dir__}/lint/constant_reassignment"
+      register_cop :ConstantResolution, "#{__dir__}/lint/constant_resolution"
+      register_cop :CopDirectiveSyntax, "#{__dir__}/lint/cop_directive_syntax"
+      register_cop :DataDefineOverride, "#{__dir__}/lint/data_define_override"
+      register_cop :Debugger, "#{__dir__}/lint/debugger"
+      register_cop :DeprecatedClassMethods, "#{__dir__}/lint/deprecated_class_methods"
+      register_cop :DeprecatedConstants, "#{__dir__}/lint/deprecated_constants"
+      register_cop :DeprecatedOpenSSLConstant, "#{__dir__}/lint/deprecated_open_ssl_constant"
+      register_cop :DeprecatedReference, "#{__dir__}/lint/deprecated_reference"
+      register_cop :DisjunctiveAssignmentInConstructor, "#{__dir__}/lint/disjunctive_assignment_in_constructor"
+      register_cop :DuplicateBranch, "#{__dir__}/lint/duplicate_branch"
+      register_cop :DuplicateCaseCondition, "#{__dir__}/lint/duplicate_case_condition"
+      register_cop :DuplicateElsifCondition, "#{__dir__}/lint/duplicate_elsif_condition"
+      register_cop :DuplicateHashKey, "#{__dir__}/lint/duplicate_hash_key"
+      register_cop :DuplicateMagicComment, "#{__dir__}/lint/duplicate_magic_comment"
+      register_cop :DuplicateMatchPattern, "#{__dir__}/lint/duplicate_match_pattern"
+      register_cop :DuplicateMethods, "#{__dir__}/lint/duplicate_methods"
+      register_cop :DuplicateRegexpCharacterClassElement, "#{__dir__}/lint/duplicate_regexp_character_class_element"
+      register_cop :DuplicateRequire, "#{__dir__}/lint/duplicate_require"
+      register_cop :DuplicateRescueException, "#{__dir__}/lint/duplicate_rescue_exception"
+      register_cop :DuplicateSetElement, "#{__dir__}/lint/duplicate_set_element"
+      register_cop :EachWithObjectArgument, "#{__dir__}/lint/each_with_object_argument"
+      register_cop :ElseLayout, "#{__dir__}/lint/else_layout"
+      register_cop :EmptyBlock, "#{__dir__}/lint/empty_block"
+      register_cop :EmptyClass, "#{__dir__}/lint/empty_class"
+      register_cop :EmptyConditionalBody, "#{__dir__}/lint/empty_conditional_body"
+      register_cop :EmptyEnsure, "#{__dir__}/lint/empty_ensure"
+      register_cop :EmptyExpression, "#{__dir__}/lint/empty_expression"
+      register_cop :EmptyFile, "#{__dir__}/lint/empty_file"
+      register_cop :EmptyInPattern, "#{__dir__}/lint/empty_in_pattern"
+      register_cop :EmptyInterpolation, "#{__dir__}/lint/empty_interpolation"
+      register_cop :EmptyWhen, "#{__dir__}/lint/empty_when"
+      register_cop :EnsureReturn, "#{__dir__}/lint/ensure_return"
+      register_cop :SharedMutableDefault, "#{__dir__}/lint/shared_mutable_default"
+      register_cop :ErbNewArguments, "#{__dir__}/lint/erb_new_arguments"
+      register_cop :FlipFlop, "#{__dir__}/lint/flip_flop"
+      register_cop :FloatComparison, "#{__dir__}/lint/float_comparison"
+      register_cop :FloatOutOfRange, "#{__dir__}/lint/float_out_of_range"
+      register_cop :FormatParameterMismatch, "#{__dir__}/lint/format_parameter_mismatch"
+      register_cop :HashCompareByIdentity, "#{__dir__}/lint/hash_compare_by_identity"
+      register_cop :HashNewWithKeywordArgumentsAsDefault, "#{__dir__}/lint/hash_new_with_keyword_arguments_as_default"
+      register_cop :HeredocMethodCallPosition, "#{__dir__}/lint/heredoc_method_call_position"
+      register_cop :IdentityComparison, "#{__dir__}/lint/identity_comparison"
+      register_cop :ImplicitStringConcatenation, "#{__dir__}/lint/implicit_string_concatenation"
+      register_cop :IncompatibleIoSelectWithFiberScheduler, "#{__dir__}/lint/incompatible_io_select_with_fiber_scheduler"
+      register_cop :IneffectiveAccessModifier, "#{__dir__}/lint/ineffective_access_modifier"
+      register_cop :InheritException, "#{__dir__}/lint/inherit_exception"
+      register_cop :InterpolationCheck, "#{__dir__}/lint/interpolation_check"
+      register_cop :ItWithoutArgumentsInBlock, "#{__dir__}/lint/it_without_arguments_in_block"
+      register_cop :LambdaWithoutLiteralBlock, "#{__dir__}/lint/lambda_without_literal_block"
+      register_cop :LiteralAsCondition, "#{__dir__}/lint/literal_as_condition"
+      register_cop :LiteralAssignmentInCondition, "#{__dir__}/lint/literal_assignment_in_condition"
+      register_cop :LiteralInInterpolation, "#{__dir__}/lint/literal_in_interpolation"
+      register_cop :Loop, "#{__dir__}/lint/loop"
+      register_cop :MisplacedMagicComment, "#{__dir__}/lint/misplaced_magic_comment"
+      register_cop :MissingCopEnableDirective, "#{__dir__}/lint/missing_cop_enable_directive"
+      register_cop :MissingSuper, "#{__dir__}/lint/missing_super"
+      register_cop :MixedCaseRange, "#{__dir__}/lint/mixed_case_range"
+      register_cop :MixedRegexpCaptureTypes, "#{__dir__}/lint/mixed_regexp_capture_types"
+      register_cop :MultipleComparison, "#{__dir__}/lint/multiple_comparison"
+      register_cop :NameTypo, "#{__dir__}/lint/name_typo"
+      register_cop :NestedMethodDefinition, "#{__dir__}/lint/nested_method_definition"
+      register_cop :NestedPercentLiteral, "#{__dir__}/lint/nested_percent_literal"
+      register_cop :NextWithoutAccumulator, "#{__dir__}/lint/next_without_accumulator"
+      register_cop :NoReturnInBeginEndBlocks, "#{__dir__}/lint/no_return_in_begin_end_blocks"
+      register_cop :NonAtomicFileOperation, "#{__dir__}/lint/non_atomic_file_operation"
+      register_cop :NonDeterministicRequireOrder, "#{__dir__}/lint/non_deterministic_require_order"
+      register_cop :NonLocalExitFromIterator, "#{__dir__}/lint/non_local_exit_from_iterator"
+      register_cop :NumberConversion, "#{__dir__}/lint/number_conversion"
+      register_cop :NumberedParameterAssignment, "#{__dir__}/lint/numbered_parameter_assignment"
+      register_cop :NumericOperationWithConstantResult, "#{__dir__}/lint/numeric_operation_with_constant_result"
+      register_cop :OrAssignmentToConstant, "#{__dir__}/lint/or_assignment_to_constant"
+      register_cop :OrderedMagicComments, "#{__dir__}/lint/ordered_magic_comments"
+      register_cop :OutOfRangeRegexpRef, "#{__dir__}/lint/out_of_range_regexp_ref"
+      register_cop :ParenthesesAsGroupedExpression, "#{__dir__}/lint/parentheses_as_grouped_expression"
+      register_cop :PercentStringArray, "#{__dir__}/lint/percent_string_array"
+      register_cop :PercentSymbolArray, "#{__dir__}/lint/percent_symbol_array"
+      register_cop :RaiseException, "#{__dir__}/lint/raise_exception"
+      register_cop :RandOne, "#{__dir__}/lint/rand_one"
+      register_cop :RedundantCopDisableDirective, "#{__dir__}/lint/redundant_cop_disable_directive"
+      register_cop :RedundantCopEnableDirective, "#{__dir__}/lint/redundant_cop_enable_directive"
+      register_cop :RedundantDirGlobSort, "#{__dir__}/lint/redundant_dir_glob_sort"
+      register_cop :RedundantRegexpQuantifiers, "#{__dir__}/lint/redundant_regexp_quantifiers"
+      register_cop :RedundantRequireStatement, "#{__dir__}/lint/redundant_require_statement"
+      register_cop :RedundantSafeNavigation, "#{__dir__}/lint/redundant_safe_navigation"
+      register_cop :RedundantSplatExpansion, "#{__dir__}/lint/redundant_splat_expansion"
+      register_cop :RedundantStringCoercion, "#{__dir__}/lint/redundant_string_coercion"
+      register_cop :RedundantTypeConversion, "#{__dir__}/lint/redundant_type_conversion"
+      register_cop :RedundantWithIndex, "#{__dir__}/lint/redundant_with_index"
+      register_cop :RedundantWithObject, "#{__dir__}/lint/redundant_with_object"
+      register_cop :RefinementImportMethods, "#{__dir__}/lint/refinement_import_methods"
+      register_cop :RegexpAsCondition, "#{__dir__}/lint/regexp_as_condition"
+      register_cop :RequireParentheses, "#{__dir__}/lint/require_parentheses"
+      register_cop :RequireRangeParentheses, "#{__dir__}/lint/require_range_parentheses"
+      register_cop :RequireRelativeSelfPath, "#{__dir__}/lint/require_relative_self_path"
+      register_cop :RescueException, "#{__dir__}/lint/rescue_exception"
+      register_cop :RescueType, "#{__dir__}/lint/rescue_type"
+      register_cop :ReturnInVoidContext, "#{__dir__}/lint/return_in_void_context"
+      register_cop :SafeNavigationConsistency, "#{__dir__}/lint/safe_navigation_consistency"
+      register_cop :SafeNavigationChain, "#{__dir__}/lint/safe_navigation_chain"
+      register_cop :SafeNavigationWithEmpty, "#{__dir__}/lint/safe_navigation_with_empty"
+      register_cop :ScriptPermission, "#{__dir__}/lint/script_permission"
+      register_cop :SelfAssignment, "#{__dir__}/lint/self_assignment"
+      register_cop :SendWithMixinArgument, "#{__dir__}/lint/send_with_mixin_argument"
+      register_cop :ShadowedArgument, "#{__dir__}/lint/shadowed_argument"
+      register_cop :ShadowedException, "#{__dir__}/lint/shadowed_exception"
+      register_cop :ShadowingOuterLocalVariable, "#{__dir__}/lint/shadowing_outer_local_variable"
+      register_cop :StructNewOverride, "#{__dir__}/lint/struct_new_override"
+      register_cop :SuperArgumentMismatch, "#{__dir__}/lint/super_argument_mismatch"
+      register_cop :SuppressedException, "#{__dir__}/lint/suppressed_exception"
+      register_cop :SuppressedExceptionInNumberConversion, "#{__dir__}/lint/suppressed_exception_in_number_conversion"
+      register_cop :SymbolConversion, "#{__dir__}/lint/symbol_conversion"
+      register_cop :Syntax, "#{__dir__}/lint/syntax"
+      register_cop :ToEnumArguments, "#{__dir__}/lint/to_enum_arguments"
+      register_cop :ToJSON, "#{__dir__}/lint/to_json"
+      register_cop :TopLevelReturnWithArgument, "#{__dir__}/lint/top_level_return_with_argument"
+      register_cop :TrailingCommaInAttributeDeclaration, "#{__dir__}/lint/trailing_comma_in_attribute_declaration"
+      register_cop :TripleQuotes, "#{__dir__}/lint/triple_quotes"
+      register_cop :UnderscorePrefixedVariableName, "#{__dir__}/lint/underscore_prefixed_variable_name"
+      register_cop :UnescapedBracketInRegexp, "#{__dir__}/lint/unescaped_bracket_in_regexp"
+      register_cop :UnexpectedBlockArity, "#{__dir__}/lint/unexpected_block_arity"
+      register_cop :UnifiedInteger, "#{__dir__}/lint/unified_integer"
+      register_cop :UnmodifiedReduceAccumulator, "#{__dir__}/lint/unmodified_reduce_accumulator"
+      register_cop :UnreachableCode, "#{__dir__}/lint/unreachable_code"
+      register_cop :UnreachableLoop, "#{__dir__}/lint/unreachable_loop"
+      register_cop :UnreachablePatternBranch, "#{__dir__}/lint/unreachable_pattern_branch"
+      register_cop :UnusedBlockArgument, "#{__dir__}/lint/unused_block_argument"
+      register_cop :UnusedMethodArgument, "#{__dir__}/lint/unused_method_argument"
+      register_cop :UnusedPrivateMethod, "#{__dir__}/lint/unused_private_method"
+      register_cop :UriEscapeUnescape, "#{__dir__}/lint/uri_escape_unescape"
+      register_cop :UriRegexp, "#{__dir__}/lint/uri_regexp"
+      register_cop :UselessAccessModifier, "#{__dir__}/lint/useless_access_modifier"
+      register_cop :UselessAssignment, "#{__dir__}/lint/useless_assignment"
+      register_cop :UselessConstantScoping, "#{__dir__}/lint/useless_constant_scoping"
+      register_cop :UselessDefaultValueArgument, "#{__dir__}/lint/useless_default_value_argument"
+      register_cop :UselessDefined, "#{__dir__}/lint/useless_defined"
+      register_cop :UselessElseWithoutRescue, "#{__dir__}/lint/useless_else_without_rescue"
+      register_cop :UselessMethodDefinition, "#{__dir__}/lint/useless_method_definition"
+      register_cop :UselessNumericOperation, "#{__dir__}/lint/useless_numeric_operation"
+      register_cop :UselessOr, "#{__dir__}/lint/useless_or"
+      register_cop :UselessRescue, "#{__dir__}/lint/useless_rescue"
+      register_cop :UselessRuby2Keywords, "#{__dir__}/lint/useless_ruby2_keywords"
+      register_cop :UselessSetterCall, "#{__dir__}/lint/useless_setter_call"
+      register_cop :UselessTimes, "#{__dir__}/lint/useless_times"
+      register_cop :Void, "#{__dir__}/lint/void"
+
+      autoload :UnusedArgument, "#{__dir__}/mixin/unused_argument"
+
+      # Utility classes for `Lint` department cops.
+      module Utils
+        autoload :NilReceiverChecker, "#{__dir__}/lint/utils/nil_receiver_checker"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/message_annotator.rb

@@ -32,7 +32,7 @@ module RuboCop
       # @param [String] cop_name for specific cop name
       # @param [Hash] cop_config configs for specific cop, from config#for_cop
       # @option cop_config [String] :StyleGuide Extension of base styleguide URL
-      # @option cop_config [String] :Reference Full reference URL
+      # @option cop_config [String] :References Full reference URLs
       # @option cop_config [String] :Details
       #
       # @param [Hash, nil] options optional
@@ -100,8 +100,12 @@ module RuboCop
       end
 
       def reference_urls
-        urls = Array(cop_config['Reference'])
-        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
+        urls = cop_config
+               .values_at('References', 'Reference') # Support legacy Reference key
+               .flat_map { |url| Array(url) }
+               .reject(&:empty?)
+
+        urls unless urls.empty?
       end
 
       def extra_details?

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

@@ -39,7 +39,7 @@ module RuboCop
       class AbcSize < Base
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+        MSG = 'Assignment Branch Condition size for `%<method>s` is too high. ' \
               '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private

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']
       #
@@ -57,6 +57,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     module Metrics
       # Checks for excessive nesting of conditional and looping constructs.
+      # Deeply nested code is harder to read, understand, and maintain.
+      # Extracting nested logic into methods improves clarity.
       #
       # You can configure if blocks are considered using the `CountBlocks` and `CountModifierForms`
       # options. When both are set to `false` (the default) blocks and modifier forms are not
@@ -11,6 +13,27 @@ module RuboCop
       # calculation as well.
       #
       # The maximum level of nesting allowed is configurable.
+      #
+      # @example Max: 3 (default)
+      #   # bad
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         if condition4
+      #           do_something
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   if condition1
+      #     if condition2
+      #       if condition3
+      #         do_something
+      #       end
+      #     end
+      #   end
       class BlockNesting < Base
         NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 

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

@@ -40,6 +40,8 @@ module RuboCop
       class ClassLength < Base
         include CodeLength
 
+        LABEL = 'Class'
+
         def on_class(node)
           check_code_length(node)
         end
@@ -60,8 +62,8 @@ module RuboCop
 
         private
 
-        def message(length, max_length)
-          format('Class has too many lines. [%<length>d/%<max>d]', length: length, max: max_length)
+        def cop_label
+          LABEL
         end
 
         def find_expression_within_parent(parent)

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

@@ -75,7 +75,7 @@ module RuboCop
         private
 
         def collection_threshold
-          cop_config.fetch('LengthThreshold', Float::INFINITY)
+          cop_config.fetch('Max', Float::INFINITY)
         end
       end
     end