rubocop 1.88.2 → 1.90.0

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/ambiguous_range.rb

@@ -83,14 +83,13 @@ module RuboCop
           yield range.end if range.end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
             node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def acceptable_call?(node)
           return true if node.unary_operation?

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls that pass the wrong number of positional arguments to a
+      # method whose definition is known from the project index.
+      #
+      # 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 calls on constant receivers (`Foo.bar`) are considered, and only
+      # when the receiver resolves in the index, its entire ancestry is resolved
+      # (so a method inherited from a gem or the standard library never produces
+      # an offense), and the called method resolves to a single, unambiguous
+      # signature. Calls that forward arguments (`*`, `**`, `...`) are skipped
+      # because their argument count is not statically known. Keyword arguments
+      # passed to a method that declares no keyword parameters are counted as the
+      # single positional hash they collapse into, matching Ruby's semantics.
+      #
+      # Constructor calls (`Foo.new`) and keyword-argument validation are out of
+      # scope: only positional arity of explicitly defined singleton methods is
+      # checked.
+      #
+      # @example
+      #   # Given the project defines:
+      #   #   class Report
+      #   #     def self.generate(source, format); end
+      #   #   end
+      #
+      #   # bad
+      #   Report.generate(source)
+      #
+      #   # bad
+      #   Report.generate(source, :pdf, :extra)
+      #
+      #   # good
+      #   Report.generate(source, :pdf)
+      #
+      class ArgumentMismatch < Base
+        include ProjectIndexHelp
+        include IndexedMethodArity
+
+        MSG = 'Wrong number of arguments to `%<method>s` (given %<given>d, expected %<expected>s).'
+
+        def on_send(node)
+          return unless project_index
+          return unless node.receiver&.const_type?
+
+          shape = resolved_signature_shape(node)
+          return unless shape
+
+          min, max, has_keywords = shape
+          given = positional_argument_count(node, has_keywords)
+          return if given.nil? || arity_satisfied?(given, min, max)
+
+          add_offense(node.loc.selector, message: message(node, given, min, max))
+        end
+        alias on_csend on_send
+
+        private
+
+        def message(node, given, min, max)
+          format(MSG, method: node.method_name, given: given, expected: expected_range(min, max))
+        end
+
+        # `[min, max, has_keywords]` for the called singleton method, or nil when
+        # the receiver or its ancestry is not resolved.
+        def resolved_signature_shape(node)
+          declaration = resolve_constant_in_index(node.receiver)
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil unless fully_resolved_index_ancestry?(declaration)
+
+          singleton_signature_shape(declaration, node.method_name)
+        rescue StandardError
+          nil
+        end
+
+        def singleton_signature_shape(declaration, method_name)
+          member = indexed_singleton_member(declaration, "#{method_name}()")
+          return nil unless member
+
+          indexed_member_shape(member)
+        end
+      end
+    end
+  end
+end

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

@@ -175,10 +175,19 @@ module RuboCop
         end
 
         def ancestor_namespaces(node)
-          node
-            .each_ancestor(:class, :module)
-            .map { |ancestor| ancestor.identifier.short_name }
-            .reverse
+          ancestors = node.each_ancestor(:class, :module).reverse_each
+
+          ancestors.with_object([]) do |ancestor, namespaces|
+            append_namespaces(namespaces, ancestor.identifier)
+          end
+        end
+
+        # Compact definitions (e.g. `module A::B`) contribute every path segment,
+        # and an absolute one (e.g. `module ::A::B`) discards the enclosing namespaces.
+        def append_namespaces(namespaces, identifier)
+          namespaces.clear if identifier.absolute?
+          namespaces.concat(identifier_namespaces(identifier))
+          namespaces << identifier.short_name
         end
 
         def unconditional_definition?(node)
@@ -188,14 +197,11 @@ module RuboCop
         end
 
         def definition_name(node)
-          identifier = node.identifier
+          namespaces = ancestor_namespaces(node)
+          append_namespaces(namespaces, node.identifier)
+          constant = namespaces.pop
 
-          if identifier.namespace&.cbase_type?
-            fully_qualified_name_for([], identifier.short_name)
-          else
-            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
-            fully_qualified_name_for(namespaces, identifier.short_name)
-          end
+          fully_qualified_name_for(namespaces, constant)
         end
 
         def identifier_namespaces(identifier)
@@ -209,21 +215,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/cop_directive_syntax.rb

@@ -42,29 +42,70 @@ module RuboCop
       #   # good
       #   # rubocop:disable Layout/LineLength -- comment
       #
+      #   # bad
+      #   # rucocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLenght
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
       class CopDirectiveSyntax < Base
         COMMON_MSG = 'Malformed directive comment detected.'
 
         MISSING_MODE_NAME_MSG = 'The mode name is missing.'
-        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `todo`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, `disable-next`, `todo`, `todo-next`, `push`, or `pop`.' # rubocop:disable Layout/LineLength
         MISSING_COP_NAME_MSG = 'The cop name is missing.'
         MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
                                   'Comment in the directive must start with `--`.'
+        NEXT_DIRECTIVE_AT_EOL_MSG = 'A `-next` directive must be on its own line, above the ' \
+                                    'statement it applies to.'
+        INVALID_KEYWORD_MSG = 'The directive keyword must be `rubocop`, not `%<keyword>s`.'
+        UNKNOWN_COP_MSG = 'Unknown cop name `%<name>s`%<suggestion>s.'
+
+        # A comment that looks like an attempted directive: any keyword
+        # followed by a colon and a valid mode name.
+        NEAR_MISS_KEYWORD_REGEXP = /
+          \A\#+\s*(?<keyword>[A-Za-z][\w-]*)\s*:\s*
+          (?:#{DirectiveComment::MODES_PATTERN})\b
+        /x.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
             directive_comment = DirectiveComment.new(comment)
-            next unless directive_comment.start_with_marker?
-            next unless directive_comment.malformed?
-
-            message = offense_message(directive_comment)
-            add_offense(comment, message: message)
+            if directive_comment.start_with_marker?
+              check_directive(comment, directive_comment)
+            elsif (keyword = near_miss_keyword(comment))
+              message = format("#{COMMON_MSG} #{INVALID_KEYWORD_MSG}", keyword: keyword)
+              add_offense(comment, message: message)
+            end
           end
         end
 
         private
 
-        # rubocop:disable Metrics/MethodLength
+        def check_directive(comment, directive_comment)
+          if directive_comment.malformed?
+            add_offense(comment, message: offense_message(directive_comment))
+          elsif misplaced_next_directive?(directive_comment)
+            add_offense(comment, message: NEXT_DIRECTIVE_AT_EOL_MSG)
+          elsif (name = unknown_cop_name(directive_comment))
+            add_offense(comment, message: unknown_cop_message(directive_comment, name))
+          end
+        end
+
+        # An EOL `disable-next` is not honored - it must fail loudly instead
+        # of silently doing nothing.
+        def misplaced_next_directive?(directive_comment)
+          directive_comment.disable_next? &&
+            !processed_source.comment_config.comment_only_line?(directive_comment.line_number)
+        end
+
+        # rubocop:disable-next Metrics/MethodLength
         def offense_message(directive_comment)
           comment = directive_comment.comment
           after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
@@ -81,7 +122,42 @@ module RuboCop
 
           "#{COMMON_MSG} #{additional_msg}"
         end
-        # rubocop:enable Metrics/MethodLength
+
+        def near_miss_keyword(comment)
+          match = comment.text.match(NEAR_MISS_KEYWORD_REGEXP)
+          return unless match
+
+          keyword = match[:keyword]
+          return if keyword == 'rubocop'
+
+          keyword if similar_to_rubocop?(keyword)
+        end
+
+        def similar_to_rubocop?(keyword)
+          return true if keyword.casecmp?('rubocop')
+          # `DidYouMean` is not always available - see `NameSimilarity`.
+          return false unless defined?(DidYouMean::Levenshtein)
+
+          DidYouMean::Levenshtein.distance(keyword.downcase, 'rubocop') <= 2
+        end
+
+        def unknown_cop_name(directive_comment)
+          return if directive_comment.push? || directive_comment.pop? || directive_comment.all_cops?
+
+          registry = directive_comment.cop_registry
+          directive_comment.raw_cop_names.find do |name|
+            next false if registry.department?(name)
+
+            qualified = registry.qualified_cop_name(name, nil, warn: false)
+            !registry.contains_cop_matching?([qualified])
+          end
+        end
+
+        def unknown_cop_message(directive_comment, name)
+          similar = NameSimilarity.find_similar_name(name, directive_comment.cop_registry.names)
+          suggestion = similar ? " (did you mean `#{similar}`?)" : ''
+          format(UNKNOWN_COP_MSG, name: name, suggestion: suggestion)
+        end
       end
     end
   end

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

@@ -0,0 +1,194 @@
+# 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
+
+        # Enumerated in a single pass that stops at the first non-deprecated
+        # definition, since materializing every definition of a declaration
+        # that is almost never deprecated dominates the cop's cost.
+        def deprecated?(declaration)
+          any = false
+
+          declaration.definitions.each do |definition|
+            return false unless definition.deprecated?
+
+            any = true
+          end
+
+          any
+        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