rubocop 1.91.0 → 1.92.2

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

@@ -98,22 +98,23 @@ module RuboCop
           second.int_type? ? second.to_a.first : :unknown
         end
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def range_size(range_node)
-          vals = range_node.to_a
-          return :unknown unless vals.all? { |val| val.nil? || val.int_type? }
-
-          low, high = vals.map { |val| val.nil? ? 0 : val.children[0] }
-          return :unknown unless low.zero? && high >= 0
+          low, high = range_node.to_a
+          # An endless range takes the rest of the collection, whatever its size.
+          return :unknown unless zero_or_beginless?(low) && high&.int_type? && high.value >= 0
 
           case range_node.type
           when :erange
-            (low...high).size
+            high.value
           when :irange
-            (low..high).size
+            high.value + 1
           end
         end
 
+        def zero_or_beginless?(low)
+          low.nil? || (low.int_type? && low.value.zero?)
+        end
+
         def source_range(shuffle_node, node)
           shuffle_node.loc.selector.join(node.source_range.end)
         end

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

@@ -37,15 +37,20 @@ module RuboCop
         private
 
         def check(node, var_type)
-          return unless (rhs = node.expression)
+          return unless (rhs = unparenthesized(node.expression))
 
           if rhs.send_type? && rhs.arguments.one?
             check_send_node(node, rhs, node.name, var_type)
-          elsif rhs.operator_keyword?
+          elsif rhs.operator_keyword? && rhs.logical_operator?
             check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
+        def unparenthesized(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          node
+        end
+
         def check_send_node(node, rhs, var_name, var_type)
           return unless OPS.include?(rhs.method_name)
 
@@ -68,26 +73,18 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          rhs = node.expression
+          rhs = unparenthesized(node.expression)
 
           if rhs.send_type?
-            autocorrect_send_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.method_name, rhs.first_argument)
           elsif rhs.operator_keyword?
-            autocorrect_boolean_node(corrector, node, rhs)
+            apply_autocorrect(corrector, node, rhs.loc.operator.source, rhs.rhs)
           end
         end
 
-        def autocorrect_send_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
-        end
-
-        def autocorrect_boolean_node(corrector, node, rhs)
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
-        end
-
-        def apply_autocorrect(corrector, node, rhs, operator, new_rhs)
+        def apply_autocorrect(corrector, node, operator, new_rhs)
           corrector.insert_before(node.loc.operator, operator)
-          corrector.replace(rhs, new_rhs.source)
+          corrector.replace(node.expression, new_rhs.source)
         end
       end
     end

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

@@ -121,7 +121,6 @@ module RuboCop
           tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
         end
 
-        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 
@@ -134,13 +133,11 @@ module RuboCop
               # See: https://github.com/rubocop/rubocop/issues/10791
               if token_before_semicolon&.regexp_dots?
                 node = find_node(range_nodes, token_before_semicolon)
+                corrector.wrap(node, '(', ')') if node
               elsif token_before_semicolon&.type == :tLABEL
-                node = find_node(value_omission_pair_nodes, token_before_semicolon).parent
-                space = node.parent.loc.selector.end.join(node.source_range.begin)
-                corrector.remove(space)
+                parenthesize_arguments(corrector, value_omission_hash(token_before_semicolon))
               end
 
-              corrector.wrap(node, '(', ')') if node
               corrector.remove(range)
             end
           end
@@ -161,6 +158,20 @@ module RuboCop
           end
         end
 
+        def value_omission_hash(token_before_semicolon)
+          find_node(value_omission_pair_nodes, token_before_semicolon)&.parent
+        end
+
+        def parenthesize_arguments(corrector, hash_node)
+          return unless hash_node
+
+          call = hash_node.parent
+          before_arguments = args_begin(call).begin.join(call.first_argument.source_range.begin)
+
+          corrector.replace(before_arguments, '(')
+          corrector.insert_after(call.last_argument, ')')
+        end
+
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
           exprs_lines = exprs.map(&:last_line)

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

@@ -64,6 +64,10 @@ module RuboCop
           undef unless until when while yield
         ].freeze
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodArgumentLineBreaks]
+        end
+
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return if allow_send? && !node.method?(:public_send)

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

@@ -35,6 +35,7 @@ module RuboCop
       #
       class SingleLineMethods < Base
         include Alignment
+        include EndlessMethodBodyHelp
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
@@ -67,10 +68,40 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
-                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
+          return false if body_node.parent.assignment_method?
+          return false if captures_following_code?(body_node.parent)
 
-          !body_node.type?(:begin, :kwbegin)
+          !unsupported_endless_method_body?(body_node) && endless_method_body?(body_node)
+        end
+
+        # `def foo; bar; end && baz` would become `def foo() = bar && baz`. The same goes for a def
+        # that ends an operand, as in `a && def foo; bar; end || baz`.
+        def captures_following_code?(node)
+          return false unless (parent = node.parent)
+
+          node_end = node.source_range.end_pos
+          return captures_following_code?(parent) if parent.source_range.end_pos == node_end
+
+          parent.children.first.equal?(node) && extends_endless_body?(parent, node)
+        end
+
+        def extends_endless_body?(parent, node)
+          case parent.type
+          when :and, :or then parent.logical_operator?
+          when :if then parent.ternary?
+          when :rescue then same_line?(node, parent.resbody_branches.first) # the modifier form
+          else parent.type?(:call, :range)
+          end
+        end
+
+        def unsupported_endless_method_body?(body_node)
+          body_node.basic_conditional? ||
+            NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
+        end
+
+        # The body gets parenthesized when it becomes endless, so it is no longer a command.
+        def command_body_in_argument?(body)
+          !require_parentheses?(body) && super
         end
 
         def correct_to_multiline(corrector, node)
@@ -89,8 +120,8 @@ module RuboCop
 
         def correct_to_endless(corrector, node)
           receiver = "#{node.receiver.source}." if node.receiver
-          arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
+          arguments = endless_arguments(node)
           replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
@@ -138,6 +169,13 @@ module RuboCop
           !method_body.arguments.empty? && !method_body.comparison_method?
         end
 
+        def endless_arguments(node)
+          arguments = node.arguments
+          return '()' if arguments.none?
+
+          arguments.loc.begin ? arguments.source : "(#{arguments.source})"
+        end
+
         def disallow_endless_method_style?
           return true unless config.cop_enabled?('Style/EndlessMethod')
 

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

@@ -50,7 +50,33 @@ module RuboCop
         end
 
         def redundant_parentheses?(node)
-          style == :require_no_parentheses && parentheses?(node)
+          return false unless style == :require_no_parentheses && parentheses?(node)
+
+          arguments = node.block_node.arguments
+          !arguments_require_parentheses?(arguments) && !comment_inside_parentheses?(arguments)
+        end
+
+        def arguments_require_parentheses?(arguments)
+          arguments.each_descendant(:any_block, :hash).any? do |node|
+            !node.hash_type? || node.braces?
+          end
+        end
+
+        def comment_inside_parentheses?(arguments)
+          !leading_padding(arguments).source.strip.empty? ||
+            !trailing_padding(arguments).source.strip.empty?
+        end
+
+        def leading_padding(arguments)
+          first_argument = arguments.children.first
+
+          arguments.loc.begin.end.join(first_argument.source_range.begin)
+        end
+
+        def trailing_padding(arguments)
+          last_argument = arguments.children.last
+
+          last_argument.source_range.end.join(arguments.loc.end.begin)
         end
 
         def message(_node)
@@ -62,10 +88,8 @@ module RuboCop
         end
 
         def unwanted_parentheses_corrector(corrector, node)
-          args_loc = node.loc
-
-          corrector.replace(args_loc.begin, '')
-          corrector.remove(args_loc.end)
+          corrector.remove(node.loc.begin.join(leading_padding(node)))
+          corrector.remove(trailing_padding(node).join(node.loc.end))
         end
 
         def stabby_lambda_with_args?(node)

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

@@ -143,7 +143,18 @@ module RuboCop
         def replacement(parts)
           interpolated_parts = parts.map { |part| adjust_str(part) }
 
-          "\"#{handle_quotes(interpolated_parts).join}\""
+          "\"#{join_parts(handle_quotes(interpolated_parts))}\""
+        end
+
+        def join_parts(parts)
+          parts.each_with_object(+'') do |part, result|
+            result.insert(-2, '\\') if interpolation_formed?(result, part)
+            result << part
+          end
+        end
+
+        def interpolation_formed?(preceding, part)
+          part.start_with?('{', '@', '$') && preceding.match?(/(?<!\\)(?:\\\\)*#\z/)
         end
 
         def adjust_str(part)
@@ -160,7 +171,9 @@ module RuboCop
         end
 
         def adjust_str_literal(part)
-          if single_quoted?(part)
+          if file_keyword?(part)
+            "\#{#{part.source}}"
+          elsif single_quoted?(part)
             part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
           elsif double_quoted?(part)
             # Reuse the source as written - rebuilding it from the value via
@@ -178,12 +191,16 @@ module RuboCop
           end
         end
 
+        def file_keyword?(str_node)
+          str_node.source == '__FILE__' && !str_node.parent.dstr_type?
+        end
+
         def single_quoted?(str_node)
-          str_node.source.start_with?("'")
+          str_node.loc.begin && str_node.source.start_with?("'")
         end
 
         def double_quoted?(str_node)
-          str_node.source.start_with?('"')
+          str_node.loc.begin && str_node.source.start_with?('"')
         end
 
         def mode

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

@@ -41,6 +41,12 @@ module RuboCop
         MSG = "Don't extend an instance initialized by `Struct.new`. " \
               'Use a block to customize the struct.'
 
+        # When the closing parenthesis of `Struct.new` is on its own line, omitting the
+        # parentheses in the same pass leaves a line break before the appended `do`.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
           return if defines_constants?(node.body)

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

@@ -76,6 +76,9 @@ module RuboCop
 
         def on_super(super_node)
           return unless (def_node = find_def_node(super_node))
+          # Zsuper passes a destructured argument as the original value, while
+          # `argument_list` flattens it into its parts.
+          return if def_node.arguments.any?(&:mlhs_type?)
 
           def_node_args = def_node.arguments.argument_list
           super_args = preprocess_super_args(super_node.arguments)

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

@@ -142,9 +142,11 @@ module RuboCop
         include RangeHelp
         include AllowedMethods
         include AllowedPattern
+        include PatternMatchingHelp
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
+        MSG_LAMBDA_LITERAL = 'Use `lambda(&:%<method>s)` instead of %<original>s.'
         SUPER_TYPES = %i[super zsuper].freeze
         LAMBDA_OR_PROC = %i[lambda proc].freeze
 
@@ -164,7 +166,7 @@ module RuboCop
         PATTERN
 
         def self.autocorrect_incompatible_with
-          [Layout::SpaceBeforeBlockBraces]
+          [Layout::SpaceBeforeBlockBraces, Style::TrailingCommaInArguments]
         end
 
         # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -174,6 +176,8 @@ module RuboCop
               return if proc_node?(dispatch_node)
               return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
             end
+            # A pattern accepts a lambda literal, but not `lambda(&:foo)`.
+            return if in_pattern?(node)
             return if unsafe_hash_usage?(dispatch_node)
             return if unsafe_array_usage?(dispatch_node)
             return if allowed_method_name?(dispatch_node.method_name)
@@ -207,12 +211,26 @@ module RuboCop
         end
 
         def register_offense(node, method_name, block_method_name)
-          block_start = node.loc.begin.begin_pos
-          block_end = node.loc.end.end_pos
-          range = range_between(block_start, block_end)
-          message = format(MSG, method: method_name, block_method: block_method_name)
+          range = if node.send_node.lambda_literal?
+                    node.source_range
+                  else
+                    node.loc.begin.begin.join(node.loc.end.end)
+                  end
+          message = message(node, method_name, block_method_name)
 
-          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
+          add_offense(range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def message(node, method_name, block_method_name)
+          if node.send_node.lambda_literal?
+            original = node.single_line? ? "`#{node.source}`" : 'a lambda literal with a block'
+
+            format(MSG_LAMBDA_LITERAL, method: method_name, original: original)
+          else
+            format(MSG, method: method_name, block_method: block_method_name)
+          end
         end
 
         def autocorrect(corrector, node)

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

@@ -58,6 +58,7 @@ module RuboCop
         include SafeAssignment
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        include ReparsedEquivalence
         extend AutoCorrector
 
         VARIABLE_TYPES = AST::Node::VARIABLES
@@ -101,7 +102,8 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition) ||
+                         verified_by_reparse([condition]).empty?)
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -218,6 +220,26 @@ module RuboCop
           end
         end
 
+        # Whatever binds looser than the ternary operator (`n += 1`, `a rescue b`,
+        # a nested ternary, `yield a`, several statements, ...) changes
+        # meaning without the parentheses, so their removal is verified by
+        # reparsing.
+        def apply_reparse_correction(corrector, condition)
+          correct_parenthesized(corrector, condition)
+        end
+
+        # The removed parentheses are the only expected difference.
+        def normalize_reparsed_ast(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| normalize_reparsed_ast(child) }
+          if node.begin_type? && children.one? && children.first.is_a?(::Parser::AST::Node)
+            children.first
+          else
+            node.updated(nil, children)
+          end
+        end
+
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end

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

@@ -35,19 +35,20 @@ module RuboCop
 
         MSG = 'Do not use trailing `_`s in parallel assignment. Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        ARRAY_OPENING = '['
         DISALLOW = %i[lvasgn splat].freeze
         private_constant :DISALLOW
 
         def on_masgn(node)
-          ranges = unneeded_ranges(node)
-
-          ranges.each do |range|
+          unneeded_ranges(node).each do |range, replacement|
+            closing = replacement == ARRAY_OPENING ? ']' : ''
             good_code = node.source
             offset = range.begin_pos - node.source_range.begin_pos
-            good_code[offset, range.size] = ''
+            good_code[offset, range.size] = replacement
 
-            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
-              corrector.remove(range)
+            add_offense(range, message: format(MSG, code: "#{good_code}#{closing}")) do |corrector|
+              corrector.replace(range, replacement)
+              corrector.insert_after(node, closing) unless closing.empty?
             end
           end
         end
@@ -115,9 +116,12 @@ module RuboCop
 
           return unused_range(node, mlhs_node) if unused_variables_only?(first_offense, variables)
 
-          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
-
-          range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+          range = if Util.parentheses?(mlhs_node)
+                    range_for_parentheses(first_offense, mlhs_node)
+                  else
+                    range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+                  end
+          [range, '']
         end
 
         def children_offenses(variables)
@@ -129,17 +133,17 @@ module RuboCop
         end
 
         def unused_range(node, mlhs_node)
-          start_range = mlhs_node.source_range.begin_pos
-
           # `node` can be an `mlhs` when recursing into a nested destructuring
-          # group; only a `masgn` has a right-hand side to anchor against.
-          end_range = if node.masgn_type?
-                        node.rhs.source_range.begin_pos
-                      else
-                        mlhs_node.source_range.end_pos
-                      end
-
-          range_between(start_range, end_range)
+          # group. Removing the group could leave a dangling comma or put
+          # something after a splat, so it is collapsed into a single `_`,
+          # which the parent group handles in turn.
+          return [mlhs_node.source_range, UNDERSCORE] unless node.masgn_type?
+
+          rhs = node.rhs
+          range = range_between(mlhs_node.source_range.begin_pos, rhs.source_range.begin_pos)
+
+          # `_, _ = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          [range, rhs.array_type? && !rhs.bracketed? ? ARRAY_OPENING : '']
         end
 
         def range_for_parentheses(offense, left)

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

@@ -59,7 +59,7 @@ module RuboCop
         private
 
         def non_eligible_body?(body)
-          body&.conditional? || super
+          body&.conditional? || body&.kwbegin_type? || super
         end
       end
     end

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

@@ -104,7 +104,7 @@ module RuboCop
                     valid_yoda?(node)
 
           add_offense(node) do |corrector|
-            corrector.replace(actual_code_range(node), corrected_code(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -138,22 +138,37 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def corrected_code(node)
-          lhs = node.receiver
-          rhs = node.first_argument
-
-          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
+        def autocorrect(corrector, node)
+          if constant_portion?(node.first_argument)
+            move_argument_to_front(corrector, node)
+          else
+            move_receiver_to_back(corrector, node)
+          end
         end
 
         def constant_portion?(node)
           node.recursive_literal? || node.const_type?
         end
 
-        def actual_code_range(node)
-          range_between(node.source_range.begin_pos, node.source_range.end_pos)
+        def move_argument_to_front(corrector, node)
+          receiver = node.receiver
+
+          replacement = "#{node.first_argument.source} #{reverse_comparison(node)} "
+
+          corrector.insert_before(receiver, replacement)
+          corrector.remove(receiver.source_range.end.join(node.source_range.end))
         end
 
-        def reverse_comparison(operator)
+        def move_receiver_to_back(corrector, node)
+          argument = node.first_argument
+
+          corrector.remove(node.source_range.begin.join(argument.source_range.begin))
+          corrector.insert_after(argument, " #{reverse_comparison(node)} #{node.receiver.source}")
+        end
+
+        def reverse_comparison(node)
+          operator = node.method_name
+
           REVERSE_COMPARISON.fetch(operator.to_s, operator)
         end
 

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

@@ -43,6 +43,9 @@ module RuboCop
         MSG = 'Non-literal operand (`%<source>s`) should be first.'
 
         RESTRICT_ON_SEND = %i[* + & | ^].freeze
+        ARGUMENT_ONLY_TYPES = %i[
+          splat block_pass forwarded_args forwarded_restarg forwarded_kwrestarg
+        ].freeze
 
         def on_new_investigation
           @offended_nodes = nil
@@ -68,13 +71,19 @@ module RuboCop
         private
 
         def yoda_expression_constant?(lhs, rhs)
-          constant_portion?(lhs) && !constant_portion?(rhs)
+          constant_portion?(lhs) && !constant_portion?(rhs) && operand?(rhs)
         end
 
         def constant_portion?(node)
           node.type?(:numeric, :const)
         end
 
+        def operand?(node)
+          return false if node.hash_type? && !node.braces?
+
+          !node.type?(*ARGUMENT_ONLY_TYPES)
+        end
+
         def supported_operators
           @supported_operators ||= Array(cop_config['SupportedOperators']).freeze
         end

data/lib/rubocop/cop/team.rb

@@ -178,7 +178,7 @@ module RuboCop
         elsif defer_corrections
           @updated_source = new_source
         else
-          File.write(processed_source.file_path, new_source)
+          RuboCop::Util.replace_file_contents(processed_source.file_path, new_source)
         end
       end
 
@@ -342,20 +342,25 @@ module RuboCop
       end
 
       def each_corrector(report)
-        skips = Set.new
+        applied = []
         report.cop_reports.each do |cop_report|
-          cop = cop_report.cop
+          cop_class = cop_report.cop.class
           corrector = cop_report.corrector
 
           next if corrector.nil? || corrector.empty?
-          next if skips.include?(cop.class)
+          next if applied.any? { |other| autocorrect_incompatible?(cop_class, other) }
 
           yield corrector
 
-          skips.merge(cop.class.autocorrect_incompatible_with)
+          applied << cop_class
         end
       end
 
+      def autocorrect_incompatible?(cop_class, other)
+        cop_class.autocorrect_incompatible_with.include?(other) ||
+          other.autocorrect_incompatible_with.include?(cop_class)
+      end
+
       def suppress_clobbering
         yield
       rescue ::Parser::ClobberingError

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def used?
-          (!reassigned? && @variable.captured_by_block?) || @referenced
+          (!reassigned? && @variable.captured_by_block? && @variable.referenced?) || @referenced
         end
 
         def regexp_named_capture?