rubocop 1.91.0 → 1.92.0

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/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,14 @@ 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?
 
-          !body_node.type?(:begin, :kwbegin)
+          !unsupported_endless_method_body?(body_node) && endless_method_body?(body_node)
+        end
+
+        def unsupported_endless_method_body?(body_node)
+          body_node.basic_conditional? ||
+            NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
         end
 
         def correct_to_multiline(corrector, node)
@@ -89,8 +94,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 +143,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

@@ -160,7 +160,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 +180,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/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
 
@@ -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?

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

@@ -67,7 +67,8 @@ module RuboCop
 
             break if !assignment.branch || assignment.branch == reference.branch
 
-            unless assignment.branch.may_run_incompletely?
+            unless assignment.branch.may_run_incompletely? ||
+                   exception_may_reach?(assignment.branch, node)
               (consumed_branches ||= Set.new) << assignment.branch
             end
           end
@@ -83,6 +84,18 @@ module RuboCop
           covers?(conditional, reference_node) && !covers?(conditional.condition, reference_node)
         end
 
+        # A branch nested in the main body of `begin` can be cut short by an exception
+        # too. An earlier assignment in it is visible to a reference in the `rescue` or
+        # `ensure` clause, or after a `rescue` that handles the exception.
+        def exception_may_reach?(branch, reference_node)
+          branch.each_ancestor.any? do |ancestor|
+            next false unless ancestor.may_run_incompletely?
+            next false if covers?(ancestor.child_node, reference_node)
+
+            ancestor.control_node.rescue_type? || covers?(ancestor.control_node, reference_node)
+          end
+        end
+
         def modifier_conditional_of(node)
           node.each_ancestor(:if, :while, :until).find do |conditional|
             conditional.modifier_form? && covers?(conditional.condition, node)

data/lib/rubocop/formatter/base_formatter.rb

@@ -35,6 +35,7 @@ module RuboCop
     # * `#file_started`
     # * `#file_finished`
     # * `#file_started`
+    # * `#file_problems` (only when a cop crashed or warned on the file)
     # * `#file_finished`
     # * `#finished`
     #
@@ -88,6 +89,27 @@ module RuboCop
       # @return [void]
       def file_started(file, options); end
 
+      # @api public
+      #
+      # Invoked before `#file_finished` for a file that a cop crashed on or
+      # raised a warning for, or whose corrections went into an infinite loop.
+      # Optional: a formatter implementing the API by duck typing is skipped
+      # when it doesn't define it.
+      #
+      # @param file [String]
+      #   the file path
+      #
+      # @param errors [Array(String)]
+      #   the error messages as they're printed, without colors. A cop that
+      #   crashes on every node of a kind has a message for each, naming the
+      #   line and column.
+      #
+      # @param warnings [Array(String)]
+      #   the warning messages, in the same form
+      #
+      # @return [void]
+      def file_problems(file, errors, warnings); end
+
       # @api public
       #
       # Invoked at the end of inspecting each files.

data/lib/rubocop/formatter/formatter_set.rb

@@ -49,6 +49,10 @@ module RuboCop
         each { |f| f.file_started(file, options) }
       end
 
+      def file_problems(file, errors, warnings)
+        each { |f| f.file_problems(file, errors, warnings) if f.respond_to?(:file_problems) }
+      end
+
       def file_finished(file, offenses)
         each { |f| f.file_finished(file, offenses) }
         offenses