rubocop 1.71.1 → 1.91.0

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

@@ -0,0 +1,99 @@
+# 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. `new` is skipped outright, because `Class#new` is not in the
+      # index: any `new` the index does find sits below it in the method
+      # resolution order, where Ruby would never reach it.
+      #
+      # @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 checkable_call?(node)
+
+          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 checkable_call?(node)
+          project_index && node.receiver&.const_type? && !node.method?(:new)
+        end
+
+        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
+
+        # A call with an explicit receiver cannot reach a private method, so its
+        # signature says nothing about the call. This matters because `Object`
+        # closes the singleton ancestry of every constant, and a bare `def` at
+        # the top level of any file — what every block-based DSL produces — is a
+        # private instance method of `Object`.
+        def singleton_signature_shape(declaration, method_name)
+          member = indexed_singleton_member(declaration, "#{method_name}()")
+          return nil unless member&.public?
+
+          indexed_member_shape(member)
+        end
+      end
+    end
+  end
+end

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

@@ -51,10 +51,9 @@ module RuboCop
                       'in a regexp.'
 
         def on_interpolation(begin_node)
-          final_node = begin_node.children.last
-
-          return unless begin_node.parent.regexp_type?
+          return unless (final_node = begin_node.children.last)
           return unless final_node.array_type?
+          return unless begin_node.parent.regexp_type?
 
           if array_of_literal_values?(final_node)
             register_array_of_literal_values(begin_node, final_node)

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) ||
@@ -94,6 +106,8 @@ module RuboCop
         def traverse_node(node, &block)
           # if the node is a block, any assignments are irrelevant
           return if node.any_block_type?
+          # an assignment inside `defined?` is never executed
+          return if node.defined_type?
 
           result = yield node if ASGN_TYPES.include?(node.type)
 

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

@@ -48,7 +48,7 @@ module RuboCop
         def autocorrect(corrector, node)
           boolean_literal = node.source.delete(':')
           parent = node.parent
-          if parent&.pair_type? && node.equal?(parent.children[0])
+          if parent&.pair_type? && parent.colon? && node.equal?(parent.children[0])
             corrector.remove(parent.loc.operator)
             boolean_literal = "#{node.source} =>"
           end

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

@@ -6,9 +6,8 @@ module RuboCop
       # Checks for circular argument references in optional keyword
       # arguments and optional ordinal arguments.
       #
-      # This cop mirrors a warning produced by MRI since 2.2.
-      #
-      # NOTE: This syntax is no longer valid on Ruby 2.7 or higher.
+      # NOTE: This syntax was made invalid on Ruby 2.7 - Ruby 3.3 but is allowed
+      # again since Ruby 3.4.
       #
       # @example
       #
@@ -36,13 +35,31 @@ module RuboCop
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
+      #
+      #   # bad
+      #   def foo(pie = pie = pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # good
+      #   def foo(pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # bad
+      #   def foo(pie = cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
+      #
+      #   # good
+      #   def foo(cake = pie)
+      #     [pie, cake].each(&:heat_up)
+      #   end
       class CircularArgumentReference < Base
         extend TargetRubyVersion
 
         MSG = 'Circular argument reference - `%<arg_name>s`.'
 
-        maximum_target_ruby_version 2.6
-
         def on_kwoptarg(node)
           check_for_circular_argument_references(*node)
         end
@@ -54,10 +71,32 @@ module RuboCop
         private
 
         def check_for_circular_argument_references(arg_name, arg_value)
-          return unless arg_value.lvar_type?
-          return unless arg_value.to_a == [arg_name]
+          if arg_value.lvar_type? && arg_value.to_a == [arg_name]
+            add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+
+            return
+          end
+
+          check_assignment_chain(arg_name, arg_value)
+        end
+
+        def check_assignment_chain(arg_name, node)
+          return unless node.lvasgn_type?
+
+          seen_variables = Set[]
+          current_node = node
+
+          while current_node.lvasgn_type?
+            seen_variables << current_node.children.first
+            current_node = current_node.children.last
+          end
+
+          return unless current_node.lvar_type?
+
+          variable_node = current_node.children.first
+          return unless seen_variables.include?(variable_node) || variable_node == arg_name
 
-          add_offense(arg_value, message: format(MSG, arg_name: arg_name))
+          add_offense(current_node, message: format(MSG, arg_name: arg_name))
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
+      # Checks for overwriting an exception with an exception result by using ``rescue =>``.
       #
       # You intended to write as `rescue StandardError`.
       # However, you have written `rescue => StandardError`.
@@ -31,7 +31,7 @@ module RuboCop
 
         # @!method overwritten_constant(node)
         def_node_matcher :overwritten_constant, <<~PATTERN
-          (resbody nil? (casgn nil? $_) nil?)
+          (resbody nil? $(casgn _ _) nil?)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -41,7 +41,8 @@ module RuboCop
         def on_resbody(node)
           return unless (constant = overwritten_constant(node))
 
-          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+          message = format(MSG, constant: constant.source)
+          add_offense(node.loc.assoc, message: message) do |corrector|
             corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
           end
         end

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

@@ -6,11 +6,19 @@ module RuboCop
       # Checks for constant reassignments.
       #
       # Emulates Ruby's runtime warning "already initialized constant X"
-      # when a constant is reassigned in the same file and namespace using the
-      # `NAME = value` syntax.
+      # when a constant is reassigned in the same file and namespace.
       #
-      # The cop cannot catch all offenses, like, for example, when a constant
-      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      # The cop tracks constants defined via `NAME = value` syntax as well as
+      # class/module keyword definitions. It detects reassignment when a constant
+      # is first defined one way and then redefined using the `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when using metaprogramming
+      # (`Module#const_set`).
+      #
+      # By default the cop also cannot detect reassignment across files.
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the cop additionally consults the project-wide index and reports reassignments
+      # whose previous definition lives in another file.
       #
       # The cop only takes into account constants assigned in a "simple" way: directly
       # inside class/module definition, or within another constant. Other type of assignments
@@ -36,6 +44,14 @@ module RuboCop
       #     X = :bar
       #   end
       #
+      #   # bad
+      #   class FooError < StandardError; end
+      #   FooError = Class.new(RuntimeError)
+      #
+      #   # bad
+      #   module M; end
+      #   M = 1
+      #
       #   # good - keep only one assignment
       #   X = :bar
       #
@@ -63,22 +79,44 @@ module RuboCop
       #   end
       #
       class ConstantReassignment < Base
+        include ProjectIndexHelp
+
         MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+        CROSS_FILE_MSG = 'Constant `%<constant>s` is already assigned in `%<path>s`.'
 
         RESTRICT_ON_SEND = %i[remove_const].freeze
 
         # @!method remove_constant(node)
         def_node_matcher :remove_constant, <<~PATTERN
-          (send _ :remove_const
+          (send {nil? self} :remove_const
             ({sym str} $_))
         PATTERN
 
+        def on_class(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :class
+        end
+
+        def on_module(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :module
+        end
+
         def on_casgn(node)
           return unless fixed_constant_path?(node)
           return unless simple_assignment?(node)
-          return if constant_names.add?(fully_qualified_constant_name(node))
 
-          add_offense(node, message: format(MSG, constant: node.name))
+          name = fully_qualified_constant_name(node)
+
+          if constant_definitions.key?(name)
+            add_offense(node, message: format(MSG, constant: constant_display_name(node)))
+            return
+          end
+
+          constant_definitions[name] = :casgn
+          report_cross_file_collision(node, name, constant_display_name(node))
         end
 
         def on_send(node)
@@ -90,7 +128,7 @@ module RuboCop
 
           return if namespaces.none?
 
-          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+          constant_definitions.delete(fully_qualified_name_for(namespaces, constant))
         end
 
         private
@@ -104,7 +142,7 @@ module RuboCop
             return true if ancestor.type?(:module, :class)
 
             ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
-              freeze_method?(ancestor)
+              ancestor.type?(:masgn, :mlhs) || freeze_method?(ancestor)
           end
         end
 
@@ -128,19 +166,60 @@ module RuboCop
           ['', *namespaces, constant].join('::')
         end
 
+        def constant_display_name(node)
+          [*constant_namespaces(node), node.name].join('::')
+        end
+
         def constant_namespaces(node)
           node.each_path.select(&:const_type?).map(&:short_name)
         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
 
-        def constant_names
-          @constant_names ||= Set.new
+        # 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)
+          node.each_ancestor.all? do |ancestor|
+            ancestor.type?(:begin, :module, :class)
+          end
+        end
+
+        def definition_name(node)
+          namespaces = ancestor_namespaces(node)
+          append_namespaces(namespaces, node.identifier)
+          constant = namespaces.pop
+
+          fully_qualified_name_for(namespaces, constant)
+        end
+
+        def identifier_namespaces(identifier)
+          identifier.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def constant_definitions
+          @constant_definitions ||= {}
+        end
+
+        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.definitions))
+
+          msg = format(CROSS_FILE_MSG, constant: display_name, path: prior.location.to_file_path)
+
+          add_offense(node, message: msg)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check that certain constants are fully qualified.
+      # Checks that certain constants are fully qualified.
       #
       # This is not enabled by default because it would mark a lot of offenses
       # unnecessarily.
@@ -13,12 +13,18 @@ module RuboCop
       #
       # Large projects will over time end up with one or two constant names that
       # are problematic because of a conflict with a library or just internally
-      # using the same name a namespace and a class. To avoid too many unnecessary
-      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      # using the same name for a namespace and a class. To avoid too many unnecessary
+      # offenses, enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
-      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # this cop which is disabled by default.
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled,
+      # 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)