rubocop 1.91.0 → 1.92.2

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

@@ -114,9 +114,31 @@ module RuboCop
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          corrector.remove(not_to_receiver(node, method_call))
+          remove_negation(corrector, node, method, method_call)
           corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
-          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def remove_negation(corrector, node, method, method_call)
+          if !keep_parentheses?(node, method_call)
+            corrector.remove(not_to_receiver(node, method_call))
+            remove_end_parenthesis(corrector, node, method, method_call)
+          elsif node.parenthesized?
+            corrector.remove(node.loc.selector)
+          else
+            corrector.remove(node.loc.selector.join(node.receiver.source_range.begin))
+          end
+        end
+
+        def keep_parentheses?(node, method_call)
+          return false unless node.receiver.begin_type? || node.parenthesized?
+          return false unless method_call.operator_method?
+          return false unless (parent = node.parent)&.call_type?
+
+          binary_operator?(parent) || parent.receiver.equal?(node)
+        end
+
+        def binary_operator?(node)
+          node.operator_method? && !node.loc.dot && !node.method?(:[]) && !node.method?(:[]=)
         end
 
         def correct_inverse_block(corrector, node)

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

@@ -59,8 +59,20 @@ module RuboCop
         MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
         MSG_AVOID_IT_PARAMETER_MULTILINE = 'Avoid using `it` block parameter for multi-line blocks.'
 
+        SCOPE_TYPES = %i[any_def class module sclass].freeze
+
         minimum_target_ruby_version 3.4
 
+        # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
+        # which would leave an empty parameter list that forbids `it`.
+        def self.autocorrect_incompatible_with
+          [Style::Lambda, Style::StabbyLambdaParentheses]
+        end
+
+        def on_new_investigation
+          @it_variable_definitions = nil
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -68,9 +80,10 @@ module RuboCop
           # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
           return unless node.first_argument.arg_type?
 
-          variables = find_block_variables(node, node.first_argument.source)
+          block_argument_name = node.first_argument.source
+          return if keep_parameter_name?(node.body, block_argument_name)
 
-          variables.each do |variable|
+          find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
@@ -109,12 +122,89 @@ module RuboCop
         private
 
         def find_block_variables(node, block_argument_name)
-          return [] unless node.body
+          return [] if !node.body || it_variable_in_scope?(node)
+
+          ranges = inner_block_ranges(node.body)
+
+          block_variables(node.body, block_argument_name).reject do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def it_variable_in_scope?(node)
+          scope = nearest_scope(node)
+          return true if it_argument_in_scope?(node, scope)
 
-          node.body.each_descendant(:lvar).select do |descendant|
+          it_variable_definitions.any? do |definition|
+            nearest_scope(definition).equal?(scope) && visible_in_block?(definition, node)
+          end
+        end
+
+        def it_variable_definitions
+          @it_variable_definitions ||=
+            variable_definitions(processed_source.ast).filter_map do |name, definition|
+              definition if name == 'it'
+            end
+        end
+
+        def nearest_scope(node)
+          node.each_ancestor(*SCOPE_TYPES).first
+        end
+
+        def it_argument_in_scope?(node, scope)
+          owners = node.each_ancestor(:block).select { |block| nearest_scope(block).equal?(scope) }
+          owners << scope if scope&.any_def_type?
+
+          owners.any? { |owner| owner.arguments.argument_list.any? { |arg| arg.name == :it } }
+        end
+
+        def visible_in_block?(definition, node)
+          return true if definition.source_range.begin_pos < node.source_range.begin_pos
+
+          node.source_range.contains?(definition.source_range)
+        end
+
+        def inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        end
+
+        def keep_parameter_name?(body, block_arg_name)
+          used_within_inner_block?(body, block_arg_name) || reassigned?(body, block_arg_name)
+        end
+
+        def used_within_inner_block?(body, block_argument_name)
+          return false unless body
+
+          ranges = inner_block_ranges(body)
+
+          block_variables(body, block_argument_name).any? do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def reassigned?(body, block_argument_name)
+          return false unless body
+
+          variable_definitions(body).any? { |name, _definition| name == block_argument_name }
+        end
+
+        def block_variables(body, block_argument_name)
+          body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end
+
+        def variable_definitions(node)
+          node.each_node(:lvasgn, :match_var, :match_with_lvasgn).flat_map do |definition|
+            names = if definition.match_with_lvasgn_type?
+                      definition.children.first.each_capture(named: true).map(&:name)
+                    else
+                      [definition.children.first.to_s]
+                    end
+
+            names.map { |name| [name, definition] }
+          end
+        end
       end
     end
   end

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

@@ -75,7 +75,9 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(kwarg.source_range)
+            range = range_with_surrounding_space(kwarg.source_range, side: :left, whitespace: true)
+            with_space = range_with_surrounding_space(range, side: :right)
+
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -48,6 +48,8 @@ module RuboCop
       #       end
       class Lambda < Base
         include ConfigurableEnforcedStyle
+        include PatternMatchingHelp
+        include RescueNode
         extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
@@ -71,6 +73,7 @@ module RuboCop
           selector = node.send_node.source
 
           return unless offending_selector?(node, selector)
+          return if uncorrectable_lambda_literal?(node)
 
           add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
@@ -91,6 +94,21 @@ module RuboCop
           selector == OFFENDING_SELECTORS[:style][style][lines]
         end
 
+        def uncorrectable_lambda_literal?(node)
+          return false unless node.send_node.lambda_literal?
+          return true if in_pattern?(node)
+          return false unless rescue_or_ensure_clause?(node.body)
+
+          LambdaLiteralToMethodCorrector.new(node).replace_delimiters?
+        end
+
+        def rescue_or_ensure_clause?(body)
+          return false unless body
+          return true if body.ensure_type?
+
+          body.rescue_type? && !rescue_modifier?(body.resbody_branches.first)
+        end
+
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 
@@ -111,12 +129,27 @@ module RuboCop
 
           return unless node.arguments?
 
-          arg_str = "(#{lambda_arg_string(node.arguments)})"
+          arg_str = lambda_arg_string(node.arguments)
+          arg_str = " #{arg_str} " if space_inside_parens?
+          arg_str = "(#{arg_str})"
+          arg_str = " #{arg_str}" if space_in_lambda_literal_required?
 
           corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          %w[space compact].include?(config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle'])
+        end
+
+        def space_in_lambda_literal_required?
+          return false unless config.cop_enabled?('Layout/SpaceInLambdaLiteral')
+
+          config.for_cop('Layout/SpaceInLambdaLiteral')['EnforcedStyle'] == 'require_space'
+        end
+
         def arguments_with_whitespace(node)
           node.loc.begin.end.join(node.arguments.loc.end)
         end

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

@@ -28,8 +28,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
           # Rewriting the call rebuilds it as a single expression, which would drop
-          # any comments inside the argument list, so leave it to be fixed manually.
-          return if comments_in_node?(node)
+          # any comments or heredoc bodies inside the argument list, so leave it to be
+          # fixed manually.
+          return if comments_in_node?(node) || heredoc_argument?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -59,6 +60,10 @@ module RuboCop
           end
         end
 
+        def heredoc_argument?(node)
+          node.arguments.any? { |argument| argument.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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

@@ -112,8 +112,7 @@ module RuboCop
 
         def on_block(node)
           return unless each_block_with_push?(node)
-
-          dest_var = find_dest_var(node)
+          return unless (dest_var = find_dest_var(node))
 
           if offending_empty_array_tap?(node, dest_var)
             asgn = dest_var.declaration_node

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -30,7 +30,7 @@ module RuboCop
 
           private
 
-          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
+          def omit_parentheses(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
@@ -40,6 +40,9 @@ module RuboCop
             return if legitimate_call_with_parentheses?(node)
             return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
+            return if code_after_closing_parenthesis_on_its_own_line?(node)
+            return if comment_before_first_argument?(node)
+            return if args_parenthesized?(node)
 
             (@pending_omit_offenses ||= []) << node
           end
@@ -104,14 +107,33 @@ module RuboCop
               inside_string_interpolation?(node)
           end
 
+          def code_after_closing_parenthesis_on_its_own_line?(node)
+            closing = node.loc.end
+            return false if node.arguments.none? || node.last_argument.last_line == closing.line
+
+            rest = closing.source_line[(closing.column + 1)..].strip
+
+            !rest.empty? && !rest.start_with?('#')
+          end
+
+          # Without the parentheses, a comment before the first argument would end the call there,
+          # and a line continuation can't carry the call past a comment.
+          def comment_before_first_argument?(node)
+            return false unless (first_argument = node.first_argument)
+
+            lines = node.loc.begin.line...first_argument.first_line
+            processed_source.each_comment_in_lines(lines).any?
+          end
+
           def parentheses_at_the_end_of_multiline_call?(node)
-            node.multiline? &&
-              node.loc.begin.source_line
-                  .gsub(TRAILING_WHITESPACE_REGEX, '')
-                  .end_with?('(')
+            return false unless node.multiline?
+
+            opening = node.loc.begin
+
+            opening.source_line[(opening.column + 1)..].gsub(TRAILING_WHITESPACE_REGEX, '').empty?
           end
 
-          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
@@ -121,7 +143,9 @@ module RuboCop
               allowed_multiline_call_with_parentheses?(node) ||
               allowed_chained_call_with_parentheses?(node) ||
               assignment_in_condition?(node) ||
-              forwards_anonymous_rest_arguments?(node)
+              command_assignment_in_expression?(node) ||
+              forwards_anonymous_rest_arguments?(node) ||
+              trailing_comma?(node)
           end
 
           def call_in_literals?(node)
@@ -137,9 +161,13 @@ module RuboCop
             parent = node.parent&.any_block_type? ? node.parent.parent : node.parent
             return false unless parent
 
-            logical_operator?(parent) ||
-              (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+            if logical_operator?(parent) || command_assignment_before_keyword_operator?(parent)
+              return true
+            end
+
+            parent.send_type? && parent.arguments.any? do |argument|
+              logical_operator?(argument)
+            end
           end
 
           def call_in_optional_arguments?(node)
@@ -229,6 +257,15 @@ module RuboCop
             node.operator_keyword? && node.logical_operator?
           end
 
+          def command_assignment_before_keyword_operator?(node)
+            return false unless node.assignment?
+
+            node = node.parent while node.parent&.assignment?
+            return false unless (operator = node.parent)
+
+            operator.operator_keyword? && operator.semantic_operator?
+          end
+
           def hash_literal?(node)
             node.hash_type? && node.braces?
           end
@@ -244,7 +281,7 @@ module RuboCop
           end
 
           def assigned_before?(node, target)
-            node.assignment? && node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.source_range.begin
           end
 
           def inside_string_interpolation?(node)
@@ -261,11 +298,41 @@ module RuboCop
             parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
           end
 
+          # rubocop:disable-next Metrics/PerceivedComplexity
+          def command_assignment_in_expression?(node)
+            value = node.parent&.type?(:any_block, :rescue) ? node.parent : node
+            assignment = outermost_assignment(value)
+            return false if assignment.equal?(value)
+
+            call_in_literals?(assignment) ||
+              call_in_logical_operators?(assignment) ||
+              call_in_optional_arguments?(assignment) ||
+              call_as_argument_or_chain?(assignment) ||
+              assignment.parent&.type?(:masgn, :return, :next, :break, :defined?)
+          end
+
+          def outermost_assignment(value)
+            parent = value.parent
+            return value if !parent&.assignment? || parent.masgn_type?
+            return value unless assigned_before?(parent, value)
+
+            outermost_assignment(parent)
+          end
+
           def forwards_anonymous_rest_arguments?(node)
+            node.arguments.any? do |argument|
+              next true if argument.forwarded_restarg_type?
+
+              argument.hash_type? && argument.children.any?(&:forwarded_kwrestarg_type?)
+            end
+          end
+
+          def trailing_comma?(node)
             return false unless (last_argument = node.last_argument)
-            return true if last_argument.forwarded_restarg_type?
 
-            last_argument.hash_type? && last_argument.children.any?(&:forwarded_kwrestarg_type?)
+            range = last_argument.source_range.end.join(node.loc.end.begin)
+
+            processed_source.tokens_within(range).any?(&:comma?)
           end
         end
       end

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

@@ -242,7 +242,14 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls, Style::RescueModifier, Style::TrailingCommaInArguments]
+          [
+            Layout::HeredocArgumentClosingParenthesis,
+            Style::NestedParenthesizedCalls,
+            Style::RedundantParentheses,
+            Style::RescueModifier,
+            Style::TernaryParentheses,
+            Style::TrailingCommaInArguments
+          ]
         end
 
         def on_send(node)
@@ -269,7 +276,24 @@ module RuboCop
           return false unless node.arguments.one?
 
           first_node = node.first_argument
-          first_node.begin_type? && first_node.parenthesized_call?
+          return false unless first_node.begin_type? && first_node.parenthesized_call?
+
+          first_node.children.one? && mergeable_parentheses?(first_node.children.first)
+        end
+
+        def mergeable_parentheses?(node)
+          case node.type
+          when :and, :or
+            !node.semantic_operator?
+          when :if, :while, :until
+            !node.modifier_form?
+          when :send
+            !node.keyword?
+          when :rescue, :masgn, :match_pattern, :match_pattern_p
+            false
+          else
+            true
+          end
         end
       end
     end

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

@@ -29,10 +29,16 @@ module RuboCop
       class MethodCallWithoutArgsParentheses < Base
         include AllowedMethods
         include AllowedPattern
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        def on_new_investigation
+          @pending_ranges = []
+          super
+        end
+
         # rubocop:disable-next Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
@@ -46,15 +52,32 @@ module RuboCop
         end
         alias on_csend on_send
 
+        # The parentheses are significant when removing them changes how the
+        # code parses, e.g. when a local variable with the same name is in
+        # scope (`foo = 1; foo()`) or an operator follows (`foo() -1`). The
+        # candidates are verified together, since outside a method definition
+        # each one would otherwise reparse the whole file.
+        def on_investigation_end
+          verified_by_reparse(@pending_ranges).each do |range|
+            add_offense(range) do |corrector|
+              apply_reparse_correction(corrector, range)
+            end
+          end
+
+          super
+        end
+
         private
 
         def register_offense(node)
           range = offense_range(node)
           return if processed_source.contains_comment?(range)
 
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          @pending_ranges << range
+        end
+
+        def apply_reparse_correction(corrector, range)
+          corrector.remove(range)
         end
 
         def ineligible_node?(node)

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

@@ -127,7 +127,19 @@ module RuboCop
 
         def correct_arguments(arg_node, corrector)
           corrector.replace(arg_node.loc.begin, ' ')
-          corrector.remove(arg_node.loc.end)
+
+          if code_after_arguments?(arg_node)
+            corrector.replace(arg_node.loc.end, ';')
+          else
+            corrector.remove(arg_node.loc.end)
+          end
+        end
+
+        def code_after_arguments?(arg_node)
+          closing = arg_node.loc.end
+          rest = closing.source_line[(closing.column + 1)..].strip
+
+          !rest.empty? && !rest.start_with?(';', '#')
         end
 
         def forced_parentheses?(node)
@@ -137,8 +149,11 @@ module RuboCop
           # 3. Argument lists containing an anonymous rest arguments forwarding (`*`)
           # 4. Argument lists containing an anonymous keyword rest arguments forwarding (`**`)
           # 5. Argument lists containing an anonymous block forwarding (`&`)
-          # Removing the parens would be a syntax error here.
-          node.endless? || anonymous_arguments?(node)
+          # 6. Argument lists that begin on a line below the method name
+          # 7. Argument lists that begin with a destructuring parameter (`(a, b)`)
+          # Removing the parens would be a syntax error, or a change of the parameters, here.
+          node.endless? || anonymous_arguments?(node) || arguments_on_own_line?(node) ||
+            destructuring_first_argument?(node)
         end
 
         def require_parentheses?(args)
@@ -154,12 +169,20 @@ module RuboCop
           location = node.arguments.source_range
 
           add_offense(location, message: MSG_MISSING) do |corrector|
-            add_parentheses(node.arguments, corrector)
+            corrector.replace(range_before_arguments(node), '(')
+            corrector.insert_after(location, ')')
 
             unexpected_style_detected 'require_no_parentheses'
           end
         end
 
+        def range_before_arguments(node)
+          range = node.loc.name.end.join(node.arguments.source_range.begin)
+          last_line_break = range.source.rindex("\n")
+
+          last_line_break ? range.resize(last_line_break) : range
+        end
+
         def unwanted_parentheses(args)
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
@@ -176,6 +199,17 @@ module RuboCop
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end
+
+        def arguments_on_own_line?(node)
+          return false unless (first_argument = node.first_argument)
+          return false unless parentheses?(node.arguments)
+
+          node.arguments.loc.begin.line != first_argument.first_line
+        end
+
+        def destructuring_first_argument?(node)
+          node.first_argument&.mlhs_type?
+        end
       end
     end
   end

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

@@ -125,13 +125,19 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
+          return if node.else? || guard_clause_cop_conflict?(node)
 
           add_offense(node, message: format(message_template, type: node.type)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
+        def guard_clause_cop_conflict?(node)
+          return false unless node.if_type? && @config.cop_enabled?('Style/GuardClause')
+
+          [node.if_branch, node.else_branch].compact.any?(&:guard_clause?)
+        end
+
         def message_template
           case empty_else_style
           when :empty

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

@@ -117,17 +117,26 @@ module RuboCop
 
         def separate_mixins(node)
           arguments = node.arguments.reverse
-          mixins = ["#{node.method_name} #{arguments.first.source}"]
+          mixins = [mixin_call(node.method_name, arguments.first.source, node.parenthesized?)]
 
           arguments[1..].inject(mixins) do |replacement, arg|
-            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+            call = mixin_call(node.method_name, arg.source, node.parenthesized?)
+            replacement << "#{indent(node)}#{call}"
           end.join("\n")
         end
 
         def group_mixins(node, mixins)
           mixin_names = mixins.reverse.flat_map { |mixin| mixin.arguments.map(&:source) }
 
-          "#{node.method_name} #{mixin_names.join(', ')}"
+          mixin_call(node.method_name, mixin_names.join(', '), mixins.any?(&:parenthesized?))
+        end
+
+        def mixin_call(method_name, arguments_source, parenthesized)
+          if parenthesized
+            "#{method_name}(#{arguments_source})"
+          else
+            "#{method_name} #{arguments_source}"
+          end
         end
       end
     end