rubocop 1.88.0 → 1.89.0

data/lib/rubocop/cop/layout.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Layout` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Layout
+      extend LazyLoader
+
+      register_cop :AccessModifierIndentation, "#{__dir__}/layout/access_modifier_indentation"
+      register_cop :ArgumentAlignment, "#{__dir__}/layout/argument_alignment"
+      register_cop :ArrayAlignment, "#{__dir__}/layout/array_alignment"
+      register_cop :AssignmentIndentation, "#{__dir__}/layout/assignment_indentation"
+      register_cop :BeginEndAlignment, "#{__dir__}/layout/begin_end_alignment"
+      register_cop :BlockAlignment, "#{__dir__}/layout/block_alignment"
+      register_cop :BlockEndNewline, "#{__dir__}/layout/block_end_newline"
+      register_cop :CaseIndentation, "#{__dir__}/layout/case_indentation"
+      register_cop :ClassStructure, "#{__dir__}/layout/class_structure"
+      register_cop :ClosingHeredocIndentation, "#{__dir__}/layout/closing_heredoc_indentation"
+      register_cop :ClosingParenthesisIndentation, "#{__dir__}/layout/closing_parenthesis_indentation"
+      register_cop :CommentIndentation, "#{__dir__}/layout/comment_indentation"
+      register_cop :ConditionPosition, "#{__dir__}/layout/condition_position"
+      register_cop :DefEndAlignment, "#{__dir__}/layout/def_end_alignment"
+      register_cop :DotPosition, "#{__dir__}/layout/dot_position"
+      register_cop :ElseAlignment, "#{__dir__}/layout/else_alignment"
+      register_cop :EmptyComment, "#{__dir__}/layout/empty_comment"
+      register_cop :EmptyLineAfterGuardClause, "#{__dir__}/layout/empty_line_after_guard_clause"
+      register_cop :EmptyLineAfterMagicComment, "#{__dir__}/layout/empty_line_after_magic_comment"
+      register_cop :EmptyLineAfterMultilineCondition, "#{__dir__}/layout/empty_line_after_multiline_condition"
+      register_cop :EmptyLineBetweenDefs, "#{__dir__}/layout/empty_line_between_defs"
+      register_cop :EmptyLinesAfterModuleInclusion, "#{__dir__}/layout/empty_lines_after_module_inclusion"
+      register_cop :EmptyLinesAroundAccessModifier, "#{__dir__}/layout/empty_lines_around_access_modifier"
+      register_cop :EmptyLinesAroundArguments, "#{__dir__}/layout/empty_lines_around_arguments"
+      register_cop :EmptyLinesAroundAttributeAccessor, "#{__dir__}/layout/empty_lines_around_attribute_accessor"
+      register_cop :EmptyLinesAroundBeginBody, "#{__dir__}/layout/empty_lines_around_begin_body"
+      register_cop :EmptyLinesAroundBlockBody, "#{__dir__}/layout/empty_lines_around_block_body"
+      register_cop :EmptyLinesAroundClassBody, "#{__dir__}/layout/empty_lines_around_class_body"
+      register_cop :EmptyLinesAroundExceptionHandlingKeywords, "#{__dir__}/layout/empty_lines_around_exception_handling_keywords"
+      register_cop :EmptyLinesAroundMethodBody, "#{__dir__}/layout/empty_lines_around_method_body"
+      register_cop :EmptyLinesAroundModuleBody, "#{__dir__}/layout/empty_lines_around_module_body"
+      register_cop :EmptyLines, "#{__dir__}/layout/empty_lines"
+      register_cop :EndAlignment, "#{__dir__}/layout/end_alignment"
+      register_cop :EndOfLine, "#{__dir__}/layout/end_of_line"
+      register_cop :ExtraSpacing, "#{__dir__}/layout/extra_spacing"
+      register_cop :FirstArgumentIndentation, "#{__dir__}/layout/first_argument_indentation"
+      register_cop :FirstArrayElementIndentation, "#{__dir__}/layout/first_array_element_indentation"
+      register_cop :FirstArrayElementLineBreak, "#{__dir__}/layout/first_array_element_line_break"
+      register_cop :FirstHashElementIndentation, "#{__dir__}/layout/first_hash_element_indentation"
+      register_cop :FirstHashElementLineBreak, "#{__dir__}/layout/first_hash_element_line_break"
+      register_cop :FirstMethodArgumentLineBreak, "#{__dir__}/layout/first_method_argument_line_break"
+      register_cop :FirstMethodParameterLineBreak, "#{__dir__}/layout/first_method_parameter_line_break"
+      register_cop :FirstParameterIndentation, "#{__dir__}/layout/first_parameter_indentation"
+      register_cop :HashAlignment, "#{__dir__}/layout/hash_alignment"
+      register_cop :HeredocArgumentClosingParenthesis, "#{__dir__}/layout/heredoc_argument_closing_parenthesis"
+      register_cop :HeredocIndentation, "#{__dir__}/layout/heredoc_indentation"
+      register_cop :IndentationConsistency, "#{__dir__}/layout/indentation_consistency"
+      register_cop :IndentationStyle, "#{__dir__}/layout/indentation_style"
+      register_cop :IndentationWidth, "#{__dir__}/layout/indentation_width"
+      register_cop :InitialIndentation, "#{__dir__}/layout/initial_indentation"
+      register_cop :LeadingCommentSpace, "#{__dir__}/layout/leading_comment_space"
+      register_cop :LeadingEmptyLines, "#{__dir__}/layout/leading_empty_lines"
+      register_cop :LineContinuationLeadingSpace, "#{__dir__}/layout/line_continuation_leading_space"
+      register_cop :LineContinuationSpacing, "#{__dir__}/layout/line_continuation_spacing"
+      register_cop :LineEndStringConcatenationIndentation, "#{__dir__}/layout/line_end_string_concatenation_indentation"
+      register_cop :LineLength, "#{__dir__}/layout/line_length"
+      register_cop :MultilineArrayBraceLayout, "#{__dir__}/layout/multiline_array_brace_layout"
+      register_cop :MultilineArrayLineBreaks, "#{__dir__}/layout/multiline_array_line_breaks"
+      register_cop :MultilineAssignmentLayout, "#{__dir__}/layout/multiline_assignment_layout"
+      register_cop :MultilineBlockLayout, "#{__dir__}/layout/multiline_block_layout"
+      register_cop :MultilineHashBraceLayout, "#{__dir__}/layout/multiline_hash_brace_layout"
+      register_cop :MultilineHashKeyLineBreaks, "#{__dir__}/layout/multiline_hash_key_line_breaks"
+      register_cop :MultilineMethodArgumentLineBreaks, "#{__dir__}/layout/multiline_method_argument_line_breaks"
+      register_cop :MultilineMethodCallBraceLayout, "#{__dir__}/layout/multiline_method_call_brace_layout"
+      register_cop :MultilineMethodCallIndentation, "#{__dir__}/layout/multiline_method_call_indentation"
+      register_cop :MultilineMethodDefinitionBraceLayout, "#{__dir__}/layout/multiline_method_definition_brace_layout"
+      register_cop :MultilineMethodParameterLineBreaks, "#{__dir__}/layout/multiline_method_parameter_line_breaks"
+      register_cop :MultilineOperationIndentation, "#{__dir__}/layout/multiline_operation_indentation"
+      register_cop :ParameterAlignment, "#{__dir__}/layout/parameter_alignment"
+      register_cop :RedundantLineBreak, "#{__dir__}/layout/redundant_line_break"
+      register_cop :RescueEnsureAlignment, "#{__dir__}/layout/rescue_ensure_alignment"
+      register_cop :SingleLineBlockChain, "#{__dir__}/layout/single_line_block_chain"
+      register_cop :SpaceAfterColon, "#{__dir__}/layout/space_after_colon"
+      register_cop :SpaceAfterComma, "#{__dir__}/layout/space_after_comma"
+      register_cop :SpaceAfterMethodName, "#{__dir__}/layout/space_after_method_name"
+      register_cop :SpaceAfterNot, "#{__dir__}/layout/space_after_not"
+      register_cop :SpaceAfterSemicolon, "#{__dir__}/layout/space_after_semicolon"
+      register_cop :SpaceAroundBlockParameters, "#{__dir__}/layout/space_around_block_parameters"
+      register_cop :SpaceAroundEqualsInParameterDefault, "#{__dir__}/layout/space_around_equals_in_parameter_default"
+      register_cop :SpaceAroundKeyword, "#{__dir__}/layout/space_around_keyword"
+      register_cop :SpaceAroundMethodCallOperator, "#{__dir__}/layout/space_around_method_call_operator"
+      register_cop :SpaceAroundOperators, "#{__dir__}/layout/space_around_operators"
+      register_cop :SpaceBeforeBlockBraces, "#{__dir__}/layout/space_before_block_braces"
+      register_cop :SpaceBeforeBrackets, "#{__dir__}/layout/space_before_brackets"
+      register_cop :SpaceBeforeComma, "#{__dir__}/layout/space_before_comma"
+      register_cop :SpaceBeforeComment, "#{__dir__}/layout/space_before_comment"
+      register_cop :SpaceBeforeFirstArg, "#{__dir__}/layout/space_before_first_arg"
+      register_cop :SpaceBeforeSemicolon, "#{__dir__}/layout/space_before_semicolon"
+      register_cop :SpaceInLambdaLiteral, "#{__dir__}/layout/space_in_lambda_literal"
+      register_cop :SpaceInsideArrayPercentLiteral, "#{__dir__}/layout/space_inside_array_percent_literal"
+      register_cop :SpaceInsideArrayLiteralBrackets, "#{__dir__}/layout/space_inside_array_literal_brackets"
+      register_cop :SpaceInsideBlockBraces, "#{__dir__}/layout/space_inside_block_braces"
+      register_cop :SpaceInsideHashLiteralBraces, "#{__dir__}/layout/space_inside_hash_literal_braces"
+      register_cop :SpaceInsideParens, "#{__dir__}/layout/space_inside_parens"
+      register_cop :SpaceInsidePercentLiteralDelimiters, "#{__dir__}/layout/space_inside_percent_literal_delimiters"
+      register_cop :SpaceInsideRangeLiteral, "#{__dir__}/layout/space_inside_range_literal"
+      register_cop :SpaceInsideReferenceBrackets, "#{__dir__}/layout/space_inside_reference_brackets"
+      register_cop :SpaceInsideStringInterpolation, "#{__dir__}/layout/space_inside_string_interpolation"
+      register_cop :TrailingEmptyLines, "#{__dir__}/layout/trailing_empty_lines"
+      register_cop :TrailingWhitespace, "#{__dir__}/layout/trailing_whitespace"
+
+      autoload :EmptyLinesAroundBody, "#{__dir__}/mixin/empty_lines_around_body"
+    end
+  end
+end

data/lib/rubocop/cop/lazy_loader.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Extend a department module with this module and call `register_cop` to register
+    # the department's cops with the global registry without loading their files until
+    # a cop class itself is needed:
+    #
+    #   module RuboCop
+    #     module Cop
+    #       # The Foo department.
+    #       module Foo
+    #         extend LazyLoader
+    #
+    #         register_cop :BarBaz, "#{__dir__}/foo/bar_baz"
+    #       end
+    #     end
+    #   end
+    module LazyLoader
+      # Registers a cop for lazy loading. The cop appears in the registry by name right away,
+      # but its file is loaded only when the cop class is needed, e.g. when the cop is enabled
+      # for an inspection run.
+      #
+      # The path must be absolute so that loading does not depend on `$LOAD_PATH` and cannot resolve
+      # to another RuboCop installation.
+      #
+      # @param constant_name [Symbol] name of the cop class, e.g. `:BarBaz`
+      # @param path [String] absolute path to the file defining the cop class,
+      #   with or without the `.rb` extension
+      def register_cop(constant_name, path)
+        raise ArgumentError, "cop path must be absolute: #{path}" unless File.absolute_path?(path)
+
+        autoload constant_name, path
+
+        qualified_name = "#{name}::#{constant_name}"
+
+        Registry.global.lazy_load(Badge.for(qualified_name), qualified_name)
+      end
+    end
+  end
+end

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

@@ -19,25 +19,27 @@ module RuboCop
       #   x != y # or x = !y
       #
       class AmbiguousAssignment < Base
+        include CheckAssignment
         include RangeHelp
 
         MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
 
-        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
-
         MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
-        def on_asgn(node)
-          return unless (rhs = node.expression)
+        alias on_csend on_send
+
+        private
 
-          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless (operator = node.loc.operator)
+
+          range = range_between(operator.end_pos - 1, rhs.source_range.begin_pos + 1)
           source = range.source
           return unless MISTAKES.key?(source)
 
           add_offense(range, message: format(MSG, op: MISTAKES[source]))
         end
-
-        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
       end
     end
   end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop also detects `do...end` blocks that are likely intended for
+      # an enumerable method in the arguments but actually bind to the outer
+      # method call. For example, in `render json: data.map do |x| x end`,
+      # Ruby parses the `do...end` block as belonging to `render`, not `map`.
+      #
       # This cop can customize allowed methods with `AllowedMethods`.
       # By default, there are no allowed methods.
       #
@@ -20,6 +25,18 @@ module RuboCop
       #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
+      #   # bad
+      #   render json: data.map do |item|
+      #     item.to_h
+      #   end
+      #
+      #   # good
+      #   render json: data.map { |item| item.to_h }
+      #
+      #   # good
+      #   mapped = data.map { |item| item.to_h }
+      #   render json: mapped
+      #
       #   # good
       #   # Operator methods require no disambiguation
       #   foo == bar { |b| b.baz }
@@ -58,6 +75,19 @@ module RuboCop
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
+        MSG_DO_END_BLOCK = '`%<inner_method>s` is called without a block because the ' \
+                           '`do` block binds to `%<outer_method>s`. ' \
+                           'Use braces or extract to a variable.'
+
+        BLOCK_METHODS = %i[
+          map collect flat_map collect_concat
+          select filter find_all reject
+          find detect
+          each each_with_object each_with_index
+          reduce inject
+          sort_by min_by max_by
+          group_by filter_map
+        ].to_set.freeze
 
         def on_send(node)
           return unless node.arguments?
@@ -74,8 +104,36 @@ module RuboCop
         end
         alias on_csend on_send
 
+        def on_block(node)
+          return if node.braces?
+
+          send_node = node.send_node
+          block_method_arg = find_ambiguous_block_method(node)
+          return unless block_method_arg
+
+          add_offense(block_method_arg,
+                      message: format(MSG_DO_END_BLOCK,
+                                      inner_method: block_method_arg.method_name,
+                                      outer_method: send_node.method_name))
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
         private
 
+        def find_ambiguous_block_method(block_node)
+          send_node = block_node.send_node
+          return unless send_node.send_type? && send_node.arguments?
+          return if send_node.parenthesized?
+
+          block_method_arg = find_block_method_arg(send_node)
+          return unless block_method_arg
+          return if allowed_method?(block_method_arg.method_name) ||
+                    matches_allowed_pattern?(block_method_arg.source)
+
+          block_method_arg
+        end
+
         def ambiguous_block_association?(send_node)
           send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
         end
@@ -92,6 +150,19 @@ module RuboCop
           format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
 
+        # Only the call the `do` block could actually have attached to is a candidate:
+        # the one whose source ends where the arguments end. This skips calls chained
+        # into another call (`foo bar.map.to_a`) and calls buried inside a
+        # parenthesized subcall (`foo bar(baz.map)`), which were never block candidates.
+        def find_block_method_arg(send_node)
+          end_pos = send_node.source_range.end_pos
+
+          send_node.last_argument.each_node(:call).find do |node|
+            node.source_range.end_pos == end_pos &&
+              BLOCK_METHODS.include?(node.method_name) && !node.arguments?
+          end
+        end
+
         def wrap_in_parentheses(corrector, node)
           range = node.loc.selector.end.join(node.first_argument.source_range.begin)
 

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

@@ -78,13 +78,25 @@ module RuboCop
         end
 
         def allowed_construct?(asgn_node)
-          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+          return true if asgn_node.begin_type?
+
+          conditional_assignment?(asgn_node) || discarded_assignment?(asgn_node)
         end
 
         def conditional_assignment?(asgn_node)
           !asgn_node.loc.operator
         end
 
+        # An assignment that is a statement of a multi-statement `begin`
+        # (e.g. `(foo = bar; baz)`) has its value discarded, so it is not used
+        # as the condition. Wrapping it in parentheses would only conflict with
+        # `Style/RedundantParentheses`, so it is left alone.
+        def discarded_assignment?(asgn_node)
+          parent = asgn_node.parent
+
+          parent&.begin_type? && parent.children.size > 1
+        end
+
         def skip_children?(asgn_node)
           (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||

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

@@ -209,21 +209,12 @@ module RuboCop
         def report_cross_file_collision(node, fully_qualified_name, display_name)
           return unless project_index
           return unless (declaration = project_index[fully_qualified_name.delete_prefix('::')])
-          return unless (prior = prior_definition_in_other_file(declaration))
+          return unless (prior = prior_definition_in_other_file(declaration.definitions))
 
           msg = format(CROSS_FILE_MSG, constant: display_name, path: prior.location.to_file_path)
 
           add_offense(node, message: msg)
         end
-
-        def prior_definition_in_other_file(declaration)
-          current = processed_source.file_path
-
-          declaration.definitions.find do |definition|
-            other = definition.location.to_file_path
-            !File.identical?(other, current)
-          end
-        end
       end
     end
   end

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

@@ -20,6 +20,12 @@ module RuboCop
       # to prevent conflicting rules. This is because it respects user configurations
       # that want to enable this cop which is disabled by default.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, only genuinely ambiguous constants are reported: those
+      # that resolve to a different declaration through the surrounding
+      # nesting than they would fully qualified. This makes the cop practical
+      # to enable without `Only`/`Ignore` lists.
+      #
       # @example
       #   # By default checks every constant
       #
@@ -60,6 +66,8 @@ module RuboCop
       #   Login
       #
       class ConstantResolution < Base
+        include ProjectIndexHelp
+
         MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
 
         # @!method unqualified_const?(node)
@@ -69,12 +77,29 @@ module RuboCop
 
         def on_const(node)
           return if !unqualified_const?(node) || node.parent&.defined_module || node.loc.nil?
+          return if project_index && !ambiguous_resolution?(node)
 
           add_offense(node)
         end
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, only genuinely ambiguous
+        # references are reported: the constant resolves to a different
+        # declaration through the lexical nesting than it would fully
+        # qualified. Names that resolve identically either way, or that the
+        # index cannot resolve at all (e.g. constants from gems), are not
+        # reported.
+        def ambiguous_resolution?(node)
+          name = node.short_name.to_s
+          relative = project_index.resolve_constant(name, lexical_nesting_of(node))
+          absolute = project_index.resolve_constant(name, [])
+
+          !relative.nil? && !absolute.nil? && relative.name != absolute.name
+        rescue StandardError
+          false
+        end
+
         def const_name?(name)
           name = name.to_s
           (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)

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

@@ -75,9 +75,10 @@ module RuboCop
         MSG = 'Remove debugger entry point `%<source>s`.'
 
         def on_send(node)
+          return unless debugger_method?(node) || debugger_require?(node)
           return if assumed_usage_context?(node)
 
-          add_offense(node) if debugger_method?(node) || debugger_require?(node)
+          add_offense(node)
         end
 
         private
@@ -101,9 +102,20 @@ module RuboCop
         end
 
         def debugger_method?(send_node)
+          return false unless debugger_method_names.include?(send_node.method_name)
+
           debugger_methods.include?(chained_method_name(send_node))
         end
 
+        # The last segment of each configured debugger method, used to cheaply
+        # rule out the vast majority of `send` nodes before building the
+        # chained method name.
+        def debugger_method_names
+          @debugger_method_names ||= debugger_methods.to_set do |method|
+            method.to_s.split('.').last&.to_sym
+          end
+        end
+
         def debugger_require?(send_node)
           return false unless send_node.method?(:require) && send_node.arguments.one?
           return false unless (argument = send_node.first_argument).str_type?

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to methods and references to constants that are documented
+      # as deprecated with a YARD `@deprecated` tag.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Only references that can be resolved without type inference are checked:
+      # constants, method calls without an explicit receiver (or with `self`),
+      # which are looked up in the enclosing class or module and its ancestry,
+      # and calls whose receiver is a constant, which are looked up in that
+      # namespace's singleton class. Calls on arbitrary objects are not checked.
+      #
+      # References made from a definition that is itself deprecated are allowed,
+      # so deprecated implementations can keep calling each other.
+      #
+      # @example
+      #   # Given a deprecated method and constant:
+      #   #
+      #   #   class Api
+      #   #     # @deprecated Use `#new_method` instead.
+      #   #     def old_method
+      #   #     end
+      #   #
+      #   #     # @deprecated
+      #   #     OLD_TIMEOUT = 10
+      #   #   end
+      #
+      #   # bad
+      #   class Client < Api
+      #     def call
+      #       old_method
+      #     end
+      #
+      #     def timeout
+      #       OLD_TIMEOUT
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Client < Api
+      #     def call
+      #       new_method
+      #     end
+      #
+      #     def timeout
+      #       NEW_TIMEOUT
+      #     end
+      #   end
+      #
+      class DeprecatedReference < Base
+        include ProjectIndexHelp
+
+        METHOD_MSG = 'Method `%<name>s` is deprecated%<detail>s'
+        CONSTANT_MSG = 'Constant `%<name>s` is deprecated%<detail>s'
+
+        DEPRECATED_TAG = '@deprecated'
+        DEPRECATION_DETAIL = /#{DEPRECATED_TAG}\s+(.+)/.freeze
+
+        def on_new_investigation
+          @namespace_cache = {}
+          super
+        end
+
+        def on_send(node)
+          return unless project_index
+
+          declaration = method_declaration_for(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(METHOD_MSG, name: node.method_name, detail: detail_for(declaration))
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_const(node)
+          return unless project_index
+          return if node.parent&.defined_module
+
+          declaration = resolve_constant_in_index(node)
+          return unless declaration && deprecated?(declaration)
+          return if within_deprecated_definition?(node)
+
+          message = format(CONSTANT_MSG, name: node.const_name, detail: detail_for(declaration))
+          add_offense(node, message: message)
+        end
+
+        private
+
+        def method_declaration_for(node)
+          receiver = node.receiver
+
+          if receiver.nil? || receiver.self_type?
+            implicit_receiver_declaration(node)
+          elsif receiver.const_type?
+            const_receiver_declaration(node, receiver)
+          end
+        end
+
+        def implicit_receiver_declaration(node)
+          namespace = enclosing_namespace(node)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          if singleton_context?(node)
+            indexed_singleton_member(namespace, "#{node.method_name}()")
+          else
+            namespace.find_member("#{node.method_name}()")
+          end
+        end
+
+        def const_receiver_declaration(node, receiver)
+          namespace = resolve_constant_in_index(receiver)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          indexed_singleton_member(namespace, "#{node.method_name}()")
+        end
+
+        def enclosing_namespace(node)
+          namespace_node = node.each_ancestor(:class, :module).first
+          return project_index['Object'] unless namespace_node
+
+          @namespace_cache.fetch(namespace_node) do
+            @namespace_cache[namespace_node] = resolve_constant_in_index(namespace_node.identifier)
+          end
+        end
+
+        # Whether an implicit-receiver call runs with the class or module itself
+        # as `self` (directly in a namespace body, in a singleton method, or
+        # inside `class << self`) rather than inside an instance method.
+        def singleton_context?(node)
+          instance_def_seen = false
+
+          node.each_ancestor do |ancestor|
+            case ancestor.type
+            when :defs, :sclass
+              return true
+            when :def
+              instance_def_seen = true
+            when :class, :module
+              return !instance_def_seen
+            end
+          end
+
+          false
+        end
+
+        def deprecated?(declaration)
+          definitions = declaration.definitions.to_a
+
+          definitions.any? && definitions.all?(&:deprecated?)
+        end
+
+        # References from a definition that is itself documented as deprecated
+        # are allowed.
+        def within_deprecated_definition?(node)
+          node.each_ancestor(:any_def, :class, :module).any? do |ancestor|
+            comments = processed_source.ast_with_comments[ancestor]
+            comments.any? { |comment| comment.text.include?(DEPRECATED_TAG) }
+          end
+        end
+
+        def detail_for(declaration)
+          text = deprecation_text(declaration)
+          return '.' if text.nil? || text.empty?
+
+          text.end_with?('.') ? ": #{text}" : ": #{text}."
+        end
+
+        def deprecation_text(declaration)
+          tag_comment = declaration.definitions.to_a.filter_map do |definition|
+            definition.comments.to_a.map(&:string).find { |string| string.include?(DEPRECATED_TAG) }
+          end.first
+
+          tag_comment && tag_comment[DEPRECATION_DETAIL, 1]&.strip
+        end
+      end
+    end
+  end
+end