rubocop 1.91.0 → 1.92.2

data/lib/rubocop/cop/style/alias.rb

@@ -60,7 +60,7 @@ module RuboCop
             add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
               autocorrect(corrector, node)
             end
-          elsif node.children.none? { |arg| bareword?(arg) }
+          elsif node.children.all? { |arg| !bareword?(arg) && bareword_symbol?(arg) }
             add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
@@ -97,7 +97,7 @@ module RuboCop
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
+          preferred_args = node.children.map { |node| bareword_for(node) }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
@@ -138,6 +138,15 @@ module RuboCop
           !sym_node.source.start_with?(':') || sym_node.dsym_type?
         end
 
+        def bareword_symbol?(sym_node)
+          return false unless sym_node.sym_type?
+
+          value = sym_node.value.to_s
+          return true if value.match?(/\A[A-Za-z_]\w*[?!=]?\z/)
+
+          !sym_node.source.start_with?(':"', ":'") && !value.start_with?('@', '$')
+        end
+
         def correct_alias_method_to_alias(corrector, send_node)
           new, old = *send_node.arguments
           replacement = "alias #{identifier(new)} #{identifier(old)}"
@@ -153,17 +162,21 @@ module RuboCop
         end
 
         def correct_alias_with_symbol_args(corrector, node)
-          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
-          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
+          corrector.replace(node.new_identifier, bareword_for(node.new_identifier))
+          corrector.replace(node.old_identifier, bareword_for(node.old_identifier))
         end
 
         def identifier(node)
-          if node.sym_type?
+          if bareword_symbol?(node)
             ":#{node.children.first}"
           else
             node.source
           end
         end
+
+        def bareword_for(sym_node)
+          sym_node.value.to_s
+        end
       end
     end
   end

data/lib/rubocop/cop/style/ambiguous_endless_method_definition.rb

@@ -39,9 +39,9 @@ module RuboCop
         # @!method ambiguous_endless_method_body(node)
         def_node_matcher :ambiguous_endless_method_body, <<~PATTERN
           ^${
-            (if _ <def _>)
-            ({and or} def _)
-            ({while until} _ def)
+            (if _ <any_def _>)
+            ({and or} any_def _)
+            ({while until} _ any_def)
           }
         PATTERN
 
@@ -57,6 +57,7 @@ module RuboCop
             correct_to_multiline(corrector, node)
           end
         end
+        alias on_defs on_def
 
         private
 

data/lib/rubocop/cop/style/and_or.rb

@@ -48,6 +48,10 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::ReturnNil, Style::ReturnNilInPredicateMethodDefinition]
+        end
+
         def on_and(node)
           process_logical_operator(node) if style == :always
         end
@@ -68,13 +72,7 @@ module RuboCop
 
           message = message(node)
           add_offense(node.loc.operator, message: message) do |corrector|
-            node.each_child_node do |expr|
-              if expr.send_type?
-                correct_send(expr, corrector)
-              elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
-                correct_other(expr, corrector)
-              end
-            end
+            node.each_child_node { |expr| correct_operand(expr, corrector) }
 
             corrector.replace(node.loc.operator, node.alternate_operator)
 
@@ -82,6 +80,22 @@ module RuboCop
           end
         end
 
+        def correct_operand(expr, corrector)
+          expr = expr.send_node if expr.any_block_type?
+
+          if expr.type?(:call, :super)
+            correct_send(expr, corrector)
+          elsif wrap_in_parentheses?(expr)
+            correct_other(expr, corrector)
+          end
+        end
+
+        # These bind looser than `&&` and `||`, or can't be their operands at all.
+        def wrap_in_parentheses?(node)
+          node.type?(:return, :next, :break, :yield, :any_match_pattern, :range, :defined?) ||
+            node.assignment? || (node.if_type? && node.ternary?)
+        end
+
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
@@ -97,6 +111,7 @@ module RuboCop
           return correct_setter(node, corrector) if node.setter_method?
           return correct_other(node, corrector) if node.comparison_method?
 
+          correct_block_receiver(node, corrector)
           return unless correctable_send?(node)
 
           whitespace_before_arg_range = whitespace_before_arg(node)
@@ -116,7 +131,8 @@ module RuboCop
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
           if node.prefix_bang?
-            return unless receiver.send_type?
+            receiver = receiver.send_node if receiver.any_block_type?
+            return unless receiver.type?(:call, :super)
 
             correct_send(receiver, corrector)
           elsif node.prefix_not?
@@ -141,12 +157,23 @@ module RuboCop
           end
         end
 
+        # A method chained onto a `do` block, as in `bar baz do ... end.qux`,
+        # still needs parentheses around the arguments of the call that takes the block.
+        def correct_block_receiver(node, corrector)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver&.call_type?
+          correct_operand(receiver, corrector) if receiver&.any_block_type?
+        end
+
         def correctable_send?(node)
-          !node.parenthesized? && node.arguments? && !node.method?(:[])
+          # Operator syntax such as `a + b` or `a[b]` already binds tighter than `&&` and `||`.
+          return false if node.operator_method? && !node.loc.dot
+
+          !node.parenthesized? && node.arguments?
         end
 
         def whitespace_before_arg(node)
-          begin_paren = node.loc.selector.end_pos
+          begin_paren = node.selector.end_pos
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -153,7 +153,7 @@ module RuboCop
         BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding, Style::MethodDefParentheses]
+          [Naming::BlockForwarding, Style::EndlessMethod, Style::MethodDefParentheses]
         end
 
         def on_def(node)
@@ -169,7 +169,7 @@ module RuboCop
 
           return if send_classifications.empty?
 
-          if only_forwards_all?(send_classifications)
+          if forward_all?(send_nodes, send_classifications)
             add_forward_all_offenses(node, send_classifications, forwardable_args)
           elsif target_ruby_version >= 3.2
             add_post_ruby_32_offenses(node, send_classifications, forwardable_args)
@@ -192,11 +192,33 @@ module RuboCop
           [restarg_node, kwrestarg_node, blockarg_node]
         end
 
+        def forward_all?(send_nodes, send_classifications)
+          only_forwards_all?(send_classifications) &&
+            !anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+        end
+
         def only_forwards_all?(send_classifications)
           all_classifications = %i[all all_anonymous].freeze
           send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
+        def anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+          classified = send_classifications.map(&:first)
+
+          send_nodes.any? do |send_node|
+            classified.none? { |node| node.equal?(send_node) } &&
+              forwards_anonymous_args?(send_node)
+          end
+        end
+
+        def forwards_anonymous_args?(send_node)
+          send_node.arguments.any? do |arg|
+            next arg.children.any?(&:forwarded_kwrestarg_type?) if arg.hash_type?
+
+            arg.forwarded_restarg_type?
+          end
+        end
+
         # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
           rest_arg, kwrest_arg, block_arg = *forwardable_args
@@ -376,11 +398,16 @@ module RuboCop
 
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
-          return if node.send_type? && node.method?(:[])
+          return if node.call_type? && operator_or_setter_call?(node)
+          return unless (@parenthesized_nodes ||= Set.new.compare_by_identity).add?(node)
 
           add_parentheses(node, corrector)
         end
 
+        def operator_or_setter_call?(node)
+          node.setter_method? || (node.operator_method? && !node.loc.dot)
+        end
+
         # Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
         class SendNodeClassifier
           extend NodePattern::Macros
@@ -499,6 +526,8 @@ module RuboCop
           end
 
           def offensive_block_forwarding?
+            return false if @send_node.block_literal?
+
             @block_arg ? forwarded_block_arg : allow_offense_for_no_block?
           end
 

data/lib/rubocop/cop/style/attr.rb

@@ -50,10 +50,9 @@ module RuboCop
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 
-          node_expr = node.source_range
-          attr_expr = attr_name.source_range
-
-          remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
+          if setter&.boolean_type?
+            remove = range_between(attr_name.source_range.end_pos, setter.source_range.end_pos)
+          end
 
           corrector.replace(node.loc.selector, replacement_method(node))
           corrector.remove(remove) if remove

data/lib/rubocop/cop/style/bitwise_predicate.rb

@@ -66,16 +66,18 @@ module RuboCop
 
         # @!method bit_operation?(node)
         def_node_matcher :bit_operation?, <<~PATTERN
-          (begin
-            (send _ :& _))
+          {
+            (begin (send _ :& _))
+            (send _ :& _)
+          }
         PATTERN
 
         # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
-          return unless node.receiver&.begin_type?
+          return unless bit_operation?(node.receiver)
           return unless (preferred_method = preferred_method(node))
 
-          bit_operation = node.receiver.children.first
+          bit_operation = node.receiver.begin_type? ? node.receiver.children.first : node.receiver
           lhs, _operator, rhs = *bit_operation
 
           preferred = if preferred_method == 'allbits?' && lhs.source == node.first_argument.source

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -177,7 +177,7 @@ module RuboCop
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
         def self.autocorrect_incompatible_with
-          [Style::RedundantBegin]
+          [Layout::SpaceBeforeBlockBraces, Style::MethodCallWithArgsParentheses, Style::RedundantBegin]
         end
 
         def on_send(node)
@@ -196,6 +196,8 @@ module RuboCop
           end
         end
         alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         def on_block(node)
           return if part_of_ignored_node?(node)
@@ -292,7 +294,7 @@ module RuboCop
           corrector.replace(b, '{')
           corrector.replace(e, '}')
 
-          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
+          wrap_body_with_begin(corrector, node.body) if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -304,6 +306,8 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          return if directive_comment?(comment)
+
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
 
           # It is possible that there is code between the block and the comment
@@ -317,6 +321,10 @@ module RuboCop
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def directive_comment?(comment)
+          comment.text.match?(DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+        end
+
         def source_range_before_comment(range, comment)
           range = range.end.join(comment.source_range.begin)
 
@@ -372,6 +380,7 @@ module RuboCop
         # rubocop:disable-next Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
+          return true if collection_of_for_loop?(node)
 
           method_name = node.method_name
           return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
@@ -398,6 +407,10 @@ module RuboCop
           !modifier_rescue?(body)
         end
 
+        def collection_of_for_loop?(node)
+          node.parent&.for_type? && node.parent.collection == node
+        end
+
         def modifier_rescue?(rescue_node)
           return false if rescue_node.body.nil? || rescue_node.else_branch
           return false unless rescue_node.resbody_branches.one?
@@ -438,11 +451,20 @@ module RuboCop
         end
 
         def correction_would_break_code?(node)
-          return false unless node.keywords?
+          return loop_condition?(node) if node.braces?
 
           node.send_node.arguments? && !node.send_node.parenthesized?
         end
 
+        # A `do` in the condition of `while` or `until` is taken as the start of
+        # the loop body. Inside the body of another block it is unambiguous again.
+        def loop_condition?(node)
+          ancestors = node.each_ancestor.take_while { |ancestor| !ancestor.any_block_type? }
+          [node, *ancestors].each_cons(2).any? do |child, parent|
+            parent.type?(:while, :until) && parent.condition.equal?(child)
+          end
+        end
+
         def functional_method?(method_name)
           functional_methods.include?(method_name)
         end
@@ -490,6 +512,16 @@ module RuboCop
           node.type?(:array, :range)
         end
 
+        def wrap_body_with_begin(corrector, body)
+          heredoc_ends = body.each_node(:any_str).select(&:heredoc?).map do |str|
+            str.loc.heredoc_end
+          end
+          body_end = [body.source_range, *heredoc_ends].max_by(&:end_pos)
+
+          corrector.insert_before(body, "begin\n")
+          corrector.insert_after(body_end, "\nend")
+        end
+
         def begin_required?(block_node)
           # If the block contains `rescue` or `ensure`, it needs to be wrapped in
           # `begin`...`end` when changing `do-end` to `{}`.

data/lib/rubocop/cop/style/case_equality.rb

@@ -7,7 +7,7 @@ module RuboCop
       # The `===` operator has different behavior depending on the
       # receiver and its use outside of `case`/`when` is confusing.
       # Prefer more explicit alternatives like `is_a?`, `include?`,
-      # or `match?`.
+      # `cover?`, or `match?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
@@ -22,9 +22,11 @@ module RuboCop
       # @example
       #   # bad
       #   (1..100) === 7
+      #   ('a'..'z') === char
       #
       #   # good
       #   (1..100).include?(7)
+      #   ('a'..'z').cover?(char)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
@@ -90,9 +92,18 @@ module RuboCop
         end
 
         def begin_replacement(lhs, rhs)
-          return unless lhs.children.first&.range_type?
+          range = lhs.children.first
+          return unless range&.range_type?
 
-          "#{lhs.source}.include?(#{rhs.source})"
+          method = cover_semantics?(range) ? 'cover?' : 'include?'
+
+          "#{lhs.source}.#{method}(#{rhs.source})"
+        end
+
+        # `Range#===` behaves like `Range#cover?` since Ruby 2.7 (since Ruby 2.6 for ranges
+        # that aren't string ranges), and `Range#include?` only matches that for numeric ranges.
+        def cover_semantics?(range)
+          target_ruby_version >= 2.7 && !range.children.compact.all?(&:numeric_type?)
         end
 
         def const_replacement(lhs, rhs)

data/lib/rubocop/cop/style/case_like_if.rb

@@ -54,6 +54,10 @@ module RuboCop
 
         MSG = 'Convert `if-elsif` to `case-when`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::IfInsideElse]
+        end
+
         def on_if(node)
           return unless should_check?(node)
 
@@ -224,10 +228,9 @@ module RuboCop
         end
 
         def branch_conditions(node)
-          conditions = []
-          while node&.if_type? && !node.ternary?
+          conditions = [node.condition]
+          while (node = node.else_branch)&.if_type? && node.elsif?
             conditions << node.condition
-            node = node.else_branch
           end
           conditions
         end

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -65,6 +65,13 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
+        # `Style/StructInheritance` and `Style/DataInheritance` turn a class definition into
+        # a constant assignment in the same pass, which the compacted `class` keyword would
+        # then precede.
+        def self.autocorrect_incompatible_with
+          [Style::DataInheritance, Style::StructInheritance]
+        end
+
         def on_class(node)
           return if node.parent_class && style_for_classes != :nested
 
@@ -117,7 +124,10 @@ module RuboCop
         end
 
         def heuristic_namespace_keyword(node)
-          class_definition = node.left_sibling&.each_node(:class)&.find do |class_node|
+          left_sibling = node.left_sibling
+          return 'module' unless left_sibling.is_a?(AST::Node)
+
+          class_definition = left_sibling.each_node(:class).find do |class_node|
             class_node.identifier == node.identifier.namespace
           end
 
@@ -143,7 +153,9 @@ module RuboCop
           # making autocorrection ping-pong between the two forms.
           return if style_for_kind(node.body.type) == :nested
           return unless compactible_namespace?(node)
+          return if node.each_ancestor(:class, :module).any? { |ancestor| ignored_node?(ancestor) }
 
+          ignore_node(node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
           unindent(corrector, node)
@@ -194,33 +206,62 @@ module RuboCop
             "#{node.body.children.first.const_name}"
         end
 
-        # rubocop:disable-next Metrics/AbcSize
         def remove_end(corrector, body)
-          remove_begin_pos = if same_line?(body.loc.name, body.loc.end)
-                               body.loc.name.end_pos
-                             else
-                               body.loc.end.begin_pos - leading_spaces(body).size
-                             end
-          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
-          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+          range = if same_line?(body.loc.name, body.loc.end)
+                    single_line_end_range(body)
+                  else
+                    multiline_end_range(body)
+                  end
 
           corrector.remove(range)
         end
 
-        def unindent(corrector, node)
-          return unless node.body.children.last
+        def single_line_end_range(body)
+          raw = processed_source.raw_source
+          pos = body.loc.end.begin_pos
+          pos -= 1 while raw[pos - 1] == ' '
+          pos -= 1 if raw[pos - 1] == ';'
+          range_between(pos, body.loc.end.end_pos)
+        end
 
-          last_child_leading_spaces = leading_spaces(node.body.children.last)
-          return if spaces_size(leading_spaces(node)) == spaces_size(last_child_leading_spaces)
+        def multiline_end_range(body)
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+        end
 
-          column_delta = configured_indentation_width - spaces_size(last_child_leading_spaces)
-          return if column_delta.zero?
+        def unindent(corrector, node)
+          column_delta = unindent_column_delta(node)
+          return unless column_delta&.negative?
+
+          range = unindentable_range(node.body)
+          return unless range
 
           AlignmentCorrector.correct(
-            corrector, processed_source, node, column_delta, tab_indentation: true
+            corrector, processed_source, range, column_delta, tab_indentation: true
           )
         end
 
+        def unindent_column_delta(node)
+          body = node.body.children.last
+          return unless body
+
+          node_indentation = spaces_size(leading_spaces(node))
+          body_indentation = spaces_size(leading_spaces(body))
+
+          node_indentation + configured_indentation_width - body_indentation
+        end
+
+        def unindentable_range(body)
+          first_line = body.loc.name.line + 1
+          last_line = body.loc.end.line - 1
+          return if first_line > last_line
+
+          buffer = processed_source.buffer
+          range_between(buffer.line_range(first_line).begin_pos,
+                        buffer.line_range(last_line).end_pos)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end

data/lib/rubocop/cop/style/class_methods_definitions.rb

@@ -72,9 +72,13 @@ module RuboCop
           return unless def_self_style?
           return unless node.identifier.self_type?
           return unless all_methods_public?(node)
+          return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
+            next if inside_corrected_sclass?(node)
+
             autocorrect_sclass(node, corrector)
+            ignore_node(node)
           end
         end
 
@@ -112,6 +116,17 @@ module RuboCop
           end
         end
 
+        def no_code_after?(range)
+          trailing = processed_source.lines[range.last_line - 1][range.last_column..].to_s.strip
+          trailing = trailing.sub(/\A;+\s*/, '')
+
+          trailing.empty? || trailing.start_with?('#')
+        end
+
+        def inside_corrected_sclass?(node)
+          node.each_ancestor(:sclass).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []