rubocop 1.89.0 → 1.91.0

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

@@ -41,6 +41,7 @@ module RuboCop
 
           @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
+          prepare_alignment_data
 
           processed_source.tokens.each_cons(2) do |token1, token2|
             check_tokens(processed_source.ast, token1, token2)
@@ -95,19 +96,120 @@ module RuboCop
           end_pos = token2.begin_pos - 1
           return if end_pos <= start_pos
 
-          return if allow_for_alignment? && aligned_tok?(token2)
+          return if allow_for_alignment? && aligned_tok?(token1, token2)
 
           yield range_between(start_pos, end_pos)
         end
 
-        def aligned_tok?(token)
+        def aligned_tok?(previous_token, token)
           if token.comment?
             @aligned_comments.include?(token.line)
           else
-            aligned_with_something?(token.pos)
+            aligned_with_something?(token.pos) &&
+              (ASSIGNMENT_OR_COMPARISON_TOKENS.include?(token.type) ||
+               spacing_varies?(previous_token, token))
           end
         end
 
+        def spacing_varies?(previous_token, token)
+          by_column, typed = group_profile(token.line)
+          column = token.pos.column
+          lines, spacings = typed[[column, token.type]]
+          entries = by_column[column]
+
+          if lines.size > 1
+            uniform_alignment_allowed?(token, lines, spacings)
+          elsif entries.size > 1
+            distinct_spacings(entries).size > 1
+          else
+            nearest_spacing_varies?(previous_token, token)
+          end
+        end
+
+        def uniform_alignment_allowed?(token, lines, spacings)
+          return @alignment_verdicts[lines] if @alignment_verdicts.key?(lines)
+
+          @alignment_verdicts[lines] =
+            spacings.uniq.size > 1 || aligned_on_other_column?(token, lines)
+        end
+
+        def aligned_on_other_column?(token, lines)
+          line_set = Set.new(lines)
+          by_column, = group_profile(token.line)
+
+          by_column.any? do |column, entries|
+            next false if column == token.pos.column
+
+            shared = entries.filter_map { |line, spacing| spacing if line_set.include?(line) }
+            shared.uniq.size > 1
+          end
+        end
+
+        def distinct_spacings(entries)
+          entries.map(&:last).uniq
+        end
+
+        def group_profile(line_number)
+          group = alignment_lines(line_number)
+
+          @group_profiles[group] ||= build_group_profile(group)
+        end
+
+        def build_group_profile(group)
+          by_column = Hash.new { |hash, key| hash[key] = [] }
+          typed = Hash.new { |hash, key| hash[key] = [[], []] }
+
+          group.each { |line| record_line_spacings(by_column, typed, line) }
+
+          [by_column, typed]
+        end
+
+        def record_line_spacings(by_column, typed, line)
+          @tokens_by_line[line]&.each_cons(2) do |previous_token, token|
+            spacing = token.begin_pos - previous_token.end_pos
+            by_column[token.pos.column] << [line, spacing]
+            lines, spacings = typed[[token.pos.column, token.type]]
+            lines << line
+            spacings << spacing
+          end
+        end
+
+        def nearest_spacing_varies?(previous_token, token)
+          spacing = token.begin_pos - previous_token.end_pos
+          line_ranges = [(token.line - 1).downto(1),
+                         (token.line + 1).upto(processed_source.lines.length)]
+
+          line_ranges.any? do |line_numbers|
+            nearest_spacing_differs?(line_numbers, token, spacing)
+          end
+        end
+
+        def nearest_spacing_differs?(line_numbers, token, spacing)
+          line_numbers.each do |line|
+            break if definition_boundary_lines.include?(line)
+            next if aligned_comment_lines.include?(line)
+
+            other_spacing = spacing_before_token_at(line, token.pos.column)
+            return other_spacing != spacing if other_spacing
+          end
+
+          false
+        end
+
+        def spacing_before_token_at(line_number, column)
+          tokens = @tokens_by_line[line_number]
+          index = tokens&.index { |token| token.pos.column == column }
+          return unless index&.positive?
+
+          tokens[index].begin_pos - tokens[index - 1].end_pos
+        end
+
+        def prepare_alignment_data
+          @group_profiles = {}.compare_by_identity
+          @alignment_verdicts = {}.compare_by_identity
+          @tokens_by_line = processed_source.tokens.group_by(&:line)
+        end
+
         def ignored_range?(ast, start_pos)
           ignored_ranges(ast).any? { |r| r.include?(start_pos) }
         end

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

@@ -156,7 +156,8 @@ module RuboCop
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
           return if enforce_first_argument_with_fixed_indentation? &&
-                    !enable_layout_first_method_argument_line_break?
+                    (!enable_layout_first_method_argument_line_break? ||
+                     conflicts_with_fixed_indentation_alignment?(node))
 
           indent = base_indentation(node) + configured_indentation_width
 
@@ -309,6 +310,25 @@ module RuboCop
         def enable_layout_first_method_argument_line_break?
           config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
         end
+
+        def conflicts_with_fixed_indentation_alignment?(node)
+          return false unless special_inner_call_indentation?(node)
+          return false unless argument_alignment_applies?(node)
+
+          base_indentation(node) != indentation_of_method_line(node)
+        end
+
+        def argument_alignment_applies?(node)
+          return false if !node.call_type? || node.method?(:[]=)
+
+          node.arguments.size >= 2 ||
+            (node.first_argument.hash_type? && node.first_argument.pairs.count >= 2)
+        end
+
+        def indentation_of_method_line(node)
+          lineno = node.loc.selector ? node.loc.selector.line : node.loc.begin.line
+          processed_source.lines[lineno - 1] =~ /\S/
+        end
       end
     end
   end

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

@@ -89,15 +89,16 @@ module RuboCop
               'in an array, relative to %<base_description>s.'
 
         def on_array(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return unless node.loc.begin
+          return if autocorrect_incompatible_with_other_cops?(node, nil)
 
-          check(node, nil) if node.loc.begin
+          check(node, nil)
         end
 
         def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-
           each_argument_node(node, :array) do |array_node, left_parenthesis|
+            next if autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+
             check(array_node, left_parenthesis)
           end
         end
@@ -105,6 +106,18 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+          return false unless enforce_first_argument_with_fixed_indentation?
+          return true if style != :consistent
+
+          # `Layout/ArrayAlignment` does not align single-element arrays.
+          return false if array_node.children.size < 2
+
+          _base_column, indent_base_type =
+            indent_base(array_node.loc.begin, array_node.values.first, left_parenthesis)
+          indent_base_type != :start_of_line
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end

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

@@ -53,6 +53,7 @@ module RuboCop
         def on_def(node)
           return if node.arguments.empty?
           return if node.arguments.loc.begin.nil?
+          return if autocorrect_incompatible_with_other_cops?(node)
 
           check(node)
         end
@@ -60,6 +61,11 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(node)
+          node.arguments.size >= 2 &&
+            style == :align_parentheses && enforce_parameter_with_fixed_indentation?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
@@ -95,6 +101,11 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def enforce_parameter_with_fixed_indentation?
+          parameter_alignment_config = config.for_enabled_cop('Layout/ParameterAlignment')
+          parameter_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
       end
     end
   end

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

@@ -330,7 +330,11 @@ module RuboCop
         end
 
         def correct_no_value(corrector, key_delta, key)
-          adjust(corrector, key_delta, key)
+          adjust(corrector, clamped_key_delta(key_delta, key), key)
+        end
+
+        def clamped_key_delta(key_delta, key)
+          [key_delta, -key.column].max
         end
 
         def correct_key_value(corrector, delta, key, value, separator)
@@ -341,10 +345,7 @@ module RuboCop
           value_delta     = delta[:value]     || 0
           key_delta       = delta[:key]       || 0
 
-          key_column = key.column
-          key_delta = -key_column if key_delta < -key_column
-
-          adjust(corrector, key_delta, key)
+          adjust(corrector, clamped_key_delta(key_delta, key), key)
           adjust(corrector, separator_delta, separator)
           adjust(corrector, value_delta, value)
         end

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

@@ -400,7 +400,7 @@ module RuboCop
           if body_node.rescue_type?
             check_rescue?(body_node)
           elsif body_node.ensure_type?
-            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring -- `EnsureNode` has no accessor for the protected body
             if block_body&.rescue_type?
               check_rescue?(block_body)
             else
@@ -440,7 +440,7 @@ module RuboCop
                   begin_pos - indentation
                 end
 
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          pos = ind <= begin_pos ? ind..begin_pos : begin_pos..ind
           range_between(pos.begin, pos.end)
         end
 

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

@@ -87,7 +87,7 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
@@ -106,7 +106,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           comments.map(&:source_range)

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

@@ -104,6 +104,11 @@ module RuboCop
         alias on_defs on_def
 
         def on_new_investigation
+          @breakable_range_by_line_index = {}
+          @breakable_string_delimiters = {}
+          @endless_methods_by_line = {}
+          @heredocs = nil
+
           return unless processed_source.raw_source.include?(';')
 
           check_for_breakable_semicolons(processed_source)
@@ -288,7 +293,7 @@ module RuboCop
           source_range = node.source_range
           relevant_substr = largest_possible_string(node)
 
-          if (space_pos = relevant_substr.rindex(/\s/))
+          if (space_pos = breakable_space_position(node, relevant_substr))
             source_range.resize(space_pos + 1)
           elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
             source_range.resize(escape_pos)
@@ -300,6 +305,19 @@ module RuboCop
           end
         end
 
+        def breakable_space_position(node, substr)
+          limit = string_content_length(node) - 1
+          space_pos = substr.rindex(/\s/)
+          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos
+        end
+
+        def string_content_length(node)
+          content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
+
+          content_end - node.source_range.begin_pos
+        end
+
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
           source_range.begin_pos if source_range.column < max && source_range.last_column >= max
@@ -328,7 +346,7 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
@@ -348,7 +366,6 @@ module RuboCop
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||

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

@@ -71,7 +71,7 @@ module RuboCop
 
         BLOCK_TYPES = %i[block numblock itblock].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
@@ -80,7 +80,6 @@ module RuboCop
 
           check_by_enforced_style(node, rhs)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_by_enforced_style(node, rhs)
           case style

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

@@ -423,11 +423,11 @@ module RuboCop
         end
 
         def leftmost_call_on_same_line(node)
-          current = node.any_block_type? ? node.send_node : node
-          while current.receiver&.call_type? &&
-                current.receiver.loc?(:dot) &&
-                current.receiver.loc.dot.line == current.loc.dot.line
-            current = current.receiver
+          current = unwrap_block_node(node)
+          while (receiver = unwrap_block_node(current.receiver)) &&
+                receiver.call_type? && receiver.loc?(:dot) &&
+                receiver.loc.dot.line == current.loc.dot.line
+            current = receiver
           end
           current
         end

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

@@ -91,7 +91,7 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -111,7 +111,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         # We will use ancestor or wrapper with access modifier.
 

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

@@ -5,7 +5,8 @@ module RuboCop
     module Layout
       # Checks the spacing inside and after block parameters pipes. Line breaks
       # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
-      # not by this cop.
+      # not by this cop. Spaces inside a lambda's parameter parentheses are left
+      # to `Layout/SpaceInsideParens` when that cop enforces a conflicting style.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -29,12 +30,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- checks spacing inside a block parameter list
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(arguments)
+          check_inside_pipes(arguments) unless conflicting_space_inside_parens_style?(arguments)
           check_after_closing_pipe(arguments) if node.body
           check_each_arg(arguments)
         end
@@ -53,6 +54,16 @@ module RuboCop
           'EnforcedStyleInsidePipes'
         end
 
+        def conflicting_space_inside_parens_style?(arguments)
+          return false unless arguments.loc.begin.source == '('
+
+          case config.for_enabled_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+          when 'no_space' then style == :space
+          when 'space', 'compact' then style == :no_space
+          else false
+          end
+        end
+
         def check_inside_pipes(arguments)
           case style
           when :no_space

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

@@ -129,6 +129,12 @@ module RuboCop
           check_operator(:class, node.loc.operator, rhs)
         end
 
+        def on_def(node)
+          return unless node.endless?
+
+          check_operator(:assignment, node.loc.assignment, node.body)
+        end
+
         def on_binary(node)
           rhs = node.rhs
 
@@ -170,6 +176,7 @@ module RuboCop
         alias on_or_asgn  on_assignment
         alias on_and_asgn on_assignment
         alias on_op_asgn  on_assignment
+        alias on_defs     on_def
 
         private
 
@@ -251,7 +258,7 @@ module RuboCop
           return false unless allow_for_alignment?
           return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
 
-          return !aligned_with_operator?(operator) unless type == :assignment
+          return !aligned_with_operator?(operator) unless grouped_alignment_type?(type)
 
           token            = Token.new(operator, nil, operator.source)
           align_preceding  = aligned_with_preceding_equals_operator(token)
@@ -262,6 +269,10 @@ module RuboCop
           aligned_with_subsequent_equals_operator(token) != :yes
         end
 
+        def grouped_alignment_type?(type)
+          type == :assignment || (type == :special_asgn && force_equal_sign_alignment?)
+        end
+
         def excess_trailing_space?(right_operand, with_space)
           with_space.source.end_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_something?(right_operand))

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

@@ -153,7 +153,7 @@ module RuboCop
           [token.line - 1, token.column - 1]
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def issue_offenses(node, tokens, left, right, start_ok, end_ok)
           case style
           when :no_space
@@ -165,13 +165,12 @@ module RuboCop
             compact_offenses(node, tokens, left, right, start_ok, end_ok)
           end
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def next_to_comment?(tokens, token)
           tokens[index_for(tokens, token) + 1].comment?
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def compact_offenses(node, tokens, left, right, start_ok, end_ok)
           if qualifies_for_compact?(tokens, left, side: :left)
             compact_offense(node, left, side: :left)
@@ -185,7 +184,6 @@ module RuboCop
             space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
-        # rubocop:enable Metrics/ParameterLists
 
         def qualifies_for_compact?(tokens, token, side: :right)
           if side == :right

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,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/assignment_in_condition.rb

@@ -106,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)