rubocop 1.58.0 → 1.60.0

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

@@ -186,12 +186,12 @@ module RuboCop
           rest_arg, kwrest_arg, _block_arg = *forwardable_args
 
           send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
-            if forward_rest
+            if outside_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if forward_kwrest
+            if outside_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
@@ -250,6 +250,12 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
+        def outside_block?(node)
+          return false unless node
+
+          node.each_ancestor(:block, :numblock).none?
+        end
+
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
           add_offense(rest_arg_or_splat, message: ARGS_MSG) do |corrector|
             add_parens_if_missing(def_arguments_or_send, corrector)
@@ -340,7 +346,7 @@ module RuboCop
           end
 
           def classification
-            return nil unless forwarded_rest_arg || forwarded_kwrest_arg
+            return nil unless forwarded_rest_arg || forwarded_kwrest_arg || forwarded_block_arg
 
             if can_forward_all?
               :all
@@ -424,9 +430,16 @@ module RuboCop
           def no_additional_args?
             forwardable_count = [@rest_arg, @kwrest_arg, @block_arg].compact.size
 
+            return false if missing_rest_arg_or_kwrest_arg?
+
             @def_node.arguments.size == forwardable_count &&
               @send_node.arguments.size == forwardable_count
           end
+
+          def missing_rest_arg_or_kwrest_arg?
+            (@rest_arg_name && !forwarded_rest_arg) ||
+              (@kwrest_arg_name && !forwarded_kwrest_arg)
+          end
         end
       end
     end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Identifies usages of `arr[0]` and `arr[-1]` and suggests to change
-      # them to use `arr.first` and `arr.instead`.
+      # them to use `arr.first` and `arr.last` instead.
       #
       # The cop is disabled by default due to safety concerns.
       #

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

@@ -40,6 +40,7 @@ module RuboCop
             corrector.replace(node.loc.selector, replacement)
           end
         end
+        alias on_csend on_send
 
         def message(node)
           if node.method?(:is_a?)

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

@@ -53,7 +53,7 @@ module RuboCop
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (send !nil? {:reject :delete_if :reject!}
+          (call !nil? {:reject :delete_if :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -61,21 +61,21 @@ module RuboCop
         # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
-            (send
+            (call
               !nil? {:reject :delete_if :reject!})
             $(args ...)
-            (send
+            (call
               $(lvar _) :nil?))
         PATTERN
 
         # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
-            (send
+            (call
               !nil? {:select :select!})
             $(args ...)
-            (send
-              (send
+            (call
+              (call
                 $(lvar _) :nil?) :!))
         PATTERN
 
@@ -91,6 +91,7 @@ module RuboCop
 
           add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
         end
+        alias on_csend on_send
 
         private
 

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

@@ -105,6 +105,17 @@ module RuboCop
         def combine_with_left_sibling(corrector, node)
           corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
           corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+
+          correct_end_of_block(corrector, node)
+        end
+
+        def correct_end_of_block(corrector, node)
+          return unless node.left_sibling.respond_to?(:braces?)
+          return if node.right_sibling&.block_type? || node.right_sibling&.numblock_type?
+
+          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          corrector.remove(node.loc.end)
+          corrector.insert_before(node.source_range.end, end_of_block)
         end
       end
     end

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

@@ -63,6 +63,7 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics
+        alias on_csend on_send
 
         private
 

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

@@ -233,7 +233,7 @@ module RuboCop
         PATTERN
 
         ASSIGNMENT_TYPES.each do |type|
-          define_method "on_#{type}" do |node|
+          define_method :"on_#{type}" do |node|
             return if part_of_ignored_node?(node)
             return if node.parent&.shorthand_asgn?
 

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

@@ -49,12 +49,12 @@ module RuboCop
       class DateTime < Base
         extend AutoCorrector
 
-        CLASS_MSG = 'Prefer Time over DateTime.'
-        COERCION_MSG = 'Do not use #to_datetime.'
+        CLASS_MSG = 'Prefer `Time` over `DateTime`.'
+        COERCION_MSG = 'Do not use `#to_datetime`.'
 
         # @!method date_time?(node)
         def_node_matcher :date_time?, <<~PATTERN
-          (send (const {nil? (cbase)} :DateTime) ...)
+          (call (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
         # @!method historic_date?(node)
@@ -64,7 +64,7 @@ module RuboCop
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (send _ :to_datetime)
+          (call _ :to_datetime)
         PATTERN
 
         def on_send(node)
@@ -75,6 +75,7 @@ module RuboCop
 
           add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
+        alias on_csend on_send
 
         private
 

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

@@ -32,27 +32,27 @@ module RuboCop
 
           send_node = node.send_node
 
-          range = send_node.receiver.source_range.join(send_node.loc.selector)
-
-          add_offense(range) do |corrector|
+          add_offense(send_node) do |corrector|
             range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node, "#{max - min}.times")
+            corrector.replace(send_node, "#{max - min}.times")
           end
         end
 
         private
 
         def offending?(node)
+          return false unless node.arguments.empty?
+
           each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
         end
 
         # @!method each_range(node)
         def_node_matcher :each_range, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 (${irange erange}
                   (int $_) (int $_)))
@@ -64,7 +64,7 @@ module RuboCop
         # @!method each_range_with_zero_origin?(node)
         def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int 0) (int _)))
@@ -76,7 +76,7 @@ module RuboCop
         # @!method each_range_without_block_argument?(node)
         def_node_matcher :each_range_without_block_argument?, <<~PATTERN
           (block
-            (send
+            (call
               (begin
                 ({irange erange}
                   (int _) (int _)))

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

@@ -58,12 +58,12 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $_ $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
         def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
-          (numblock $(send _ {:inject :reduce} _) 2 $_)
+          (numblock $(call _ {:inject :reduce} _) 2 $_)
         PATTERN
 
         def autocorrect_block(corrector, node, return_value)

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

@@ -128,17 +128,6 @@ module RuboCop
           node.method?(:eval) ? node.arguments.size >= 2 : true
         end
 
-        # FIXME: It's a Style/ConditionalAssignment's false positive.
-        # rubocop:disable Style/ConditionalAssignment
-        def with_lineno?(node)
-          if node.method?(:eval)
-            node.arguments.size == 4
-          else
-            node.arguments.size == 3
-          end
-        end
-        # rubocop:enable Style/ConditionalAssignment
-
         def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff)
           expected = expected_line(sign, line_diff)
           message = format(MSG_INCORRECT_LINE,

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

@@ -30,7 +30,7 @@ module RuboCop
 
         # @!method exact_regexp_match(node)
         def_node_matcher :exact_regexp_match, <<~PATTERN
-          (send
+          (call
             _ {:=~ :=== :!~ :match :match?}
             (regexp
               (str $_)
@@ -49,6 +49,7 @@ module RuboCop
             corrector.replace(node, prefer)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -58,18 +58,20 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_block(node)
+          return unless handleable?(node)
+
           kv_each(node) do |target, method|
             register_kv_offense(target, method) and return
           end
 
           return unless (key, value = each_arguments(node))
 
-          if unused_block_arg_exist?(node, value.source)
+          if unused_block_arg_exist?(node, value)
             message = message('each_key', node.method_name, value.source)
             unused_range = key.source_range.end.join(value.source_range.end)
 
             register_each_args_offense(node, message, 'each_key', unused_range)
-          elsif unused_block_arg_exist?(node, key.source)
+          elsif unused_block_arg_exist?(node, key)
             message = message('each_value', node.method_name, key.source)
             unused_range = key.source_range.begin.join(value.source_range.begin)
 
@@ -88,6 +90,12 @@ module RuboCop
 
         private
 
+        def handleable?(node)
+          return false unless (root_receiver = root_receiver(node))
+
+          !root_receiver.literal? || root_receiver.hash_type?
+        end
+
         def register_kv_offense(target, method)
           return unless (parent_receiver = target.receiver.receiver)
           return if allowed_receiver?(parent_receiver)
@@ -99,8 +107,16 @@ module RuboCop
           end
         end
 
-        def unused_block_arg_exist?(node, block_arg_source)
-          node.body.each_descendant(:lvar).map(&:source).none?(block_arg_source)
+        def unused_block_arg_exist?(node, block_arg)
+          lvar_sources = node.body.each_descendant(:lvar).map(&:source)
+
+          if block_arg.mlhs_type?
+            block_arg.each_descendant(:arg, :restarg).all? do |block_arg|
+              lvar_sources.none?(block_arg.source.delete_prefix('*'))
+            end
+          else
+            lvar_sources.none?(block_arg.source.delete_prefix('*'))
+          end
         end
 
         def message(prefer, method_name, unused_code)
@@ -127,6 +143,15 @@ module RuboCop
           end
         end
 
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
         def format_message(method_name, current)
           format(MSG, prefer: "each_#{method_name[0..-2]}", current: current)
         end

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

@@ -43,7 +43,7 @@ module RuboCop
         # @!method bad_method_with_poro?(node)
         def_node_matcher :bad_method_with_poro?, <<~PATTERN
           (block
-            (send _ _)
+            (call _ _)
             (args
               $(arg _)
               (arg _))
@@ -86,6 +86,7 @@ module RuboCop
             corrector.replace(range, preferred_method)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -158,7 +158,10 @@ module RuboCop
           if head.assignment?
             # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
             # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
-            assigned_value = head.send_type? ? head.receiver.source : head.name.to_s
+            #
+            # FIXME: It would be better to update `RuboCop::AST::OpAsgnNode` or its subclasses to
+            # handle `self.foo ||= value` as a solution, instead of using `head.node_parts[0].to_s`.
+            assigned_value = head.send_type? ? head.receiver.source : head.node_parts[0].to_s
 
             return if condition_variable == assigned_value
           end

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

@@ -51,7 +51,7 @@ module RuboCop
       class InvertibleUnlessCondition < Base
         extend AutoCorrector
 
-        MSG = 'Favor `if` with inverted condition over `unless`.'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_if(node)
           return unless node.unless?
@@ -59,7 +59,10 @@ module RuboCop
           condition = node.condition
           return unless invertible?(condition)
 
-          add_offense(node) do |corrector|
+          message = format(MSG, prefer: "#{node.inverse_keyword} #{preferred_condition(condition)}",
+                                current: "#{node.keyword} #{condition.source}")
+
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
             autocorrect(corrector, condition)
           end
@@ -88,6 +91,40 @@ module RuboCop
             (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
         end
 
+        def preferred_condition(node)
+          case node.type
+          when :begin    then "(#{preferred_condition(node.children.first)})"
+          when :send     then preferred_send_condition(node)
+          when :or, :and then preferred_logical_condition(node)
+          end
+        end
+
+        def preferred_send_condition(node)
+          receiver_source = node.receiver.source
+          return receiver_source if node.method?(:!)
+
+          inverse_method_name = inverse_methods[node.method_name]
+          return "#{receiver_source}.#{inverse_method_name}" unless node.arguments?
+
+          argument_list = node.arguments.map(&:source).join(', ')
+          if node.operator_method?
+            return "#{receiver_source} #{inverse_method_name} #{argument_list}"
+          end
+
+          if node.parenthesized?
+            return "#{receiver_source}.#{inverse_method_name}(#{argument_list})"
+          end
+
+          "#{receiver_source}.#{inverse_method_name} #{argument_list}"
+        end
+
+        def preferred_logical_condition(node)
+          preferred_lhs = preferred_condition(node.lhs)
+          preferred_rhs = preferred_condition(node.rhs)
+
+          "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin

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

@@ -44,9 +44,9 @@ module RuboCop
 
         # @!method map_and_compact?(node)
         def_node_matcher :map_and_compact?, <<~RUBY
-          (send
+          (call
             (block
-              (send _ :map)
+              (call _ :map)
               (args
                 $(arg _))
               {
@@ -85,6 +85,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -37,8 +37,8 @@ module RuboCop
         MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 
-        # @!method map_to_h?(node)
-        def_node_matcher :map_to_h?, <<~PATTERN
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
           {
             $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
             $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
@@ -50,9 +50,9 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless (to_h_node, map_node = map_to_h?(node))
+          return unless (to_h_node, map_node = map_to_h(node))
 
-          message = format(MSG, method: map_node.loc.selector.source, dot: map_node.loc.dot.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_h` call already has a block, do not autocorrect.
             next if to_h_node.block_node
@@ -64,12 +64,17 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
           corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
           corrector.replace(map.loc.selector, 'to_h')
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -86,6 +86,7 @@ module RuboCop
 
           def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
+              node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
@@ -126,23 +127,31 @@ module RuboCop
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_with_braced_block?(node) ||
+              call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
               call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.forwarded_args_type? || n.block_type? ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) && node.block_node&.braces?
+            (node.call_type? || node.super_type?) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.block_type? && node.parent&.parent
+            return false unless parent
+
+            parent.call_type? || parent.super_type? || parent.yield_type?
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
-              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
+              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+              !assigned_before?(node.parent, node)
           end
 
           def call_in_match_pattern?(node)

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

@@ -218,15 +218,13 @@ module RuboCop
           send(style, node) # call require_parentheses or omit_parentheses
         end
         alias on_csend on_send
-        alias on_super on_send
         alias on_yield on_send
 
         private
 
         def args_begin(node)
           loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector = node.yield_type? ? loc.keyword : loc.selector
 
           resize_by = args_parenthesized?(node) ? 2 : 1
           selector.end.resize(resize_by)

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

@@ -8,6 +8,9 @@ module RuboCop
       # This cop can be customized allowed methods with `AllowedMethods`.
       # By default, there are no methods to allowed.
       #
+      # NOTE: This cop allows the use of `it()` without arguments in blocks,
+      # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
       # @example
       #   # bad
       #   object.some_method()
@@ -30,15 +33,18 @@ module RuboCop
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
           return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
+          return if parenthesized_it_method_in_block?(node)
 
           register_offense(node)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -71,6 +77,20 @@ module RuboCop
           end
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def parenthesized_it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          !node.receiver && node.arguments.empty? && !node.block_literal?
+        end
+
         def any_assignment?(node)
           node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will

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

@@ -54,12 +54,10 @@ module RuboCop
         private
 
         def offense?(node)
-          node.ternary? && node.multiline?
+          node.ternary? && node.multiline? && node.source != replacement(node)
         end
 
         def autocorrect(corrector, node)
-          return unless offense?(node)
-
           corrector.replace(node, replacement(node))
           return unless (parent = node.parent)
           return unless (comments_in_condition = comments_in_condition(node))

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

@@ -66,7 +66,7 @@ module RuboCop
         end
 
         def on_block(node)
-          return unless node.send_node.send_type? && node.send_node.enumerator_method?
+          return unless node.send_node.call_type? && node.send_node.enumerator_method?
 
           check(node)
         end

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

@@ -62,7 +62,7 @@ module RuboCop
         private
 
         def message(node)
-          self.class.const_get("#{literal_type(node).upcase}_MSG")
+          self.class.const_get(:"#{literal_type(node).upcase}_MSG")
         end
 
         def literal_type(node)