rubocop 1.57.2 → 1.59.0

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

@@ -534,7 +534,7 @@ module RuboCop
           end
 
           def element_assignment?(node)
-            node.send_type? && node.method_name != :[]=
+            node.send_type? && !node.method?(:[]=)
           end
 
           def extract_branches(node)

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_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/empty_literal.rb

@@ -83,7 +83,7 @@ module RuboCop
           parent = node.parent
           return false unless parent && %i[send super zsuper].include?(parent.type)
 
-          node.equal?(parent.arguments.first) && !parentheses?(node.parent)
+          node.equal?(parent.first_argument) && !parentheses?(node.parent)
         end
 
         def replacement_range(node)

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

@@ -84,7 +84,7 @@ module RuboCop
           # are considered.
           return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
 
-          code = node.arguments.first
+          code = node.first_argument
           return unless code && (code.str_type? || code.dstr_type?)
 
           check_location(node, code)
@@ -165,7 +165,7 @@ module RuboCop
         end
 
         def check_line(node, code)
-          line_node = node.arguments.last
+          line_node = node.last_argument
           line_diff = line_difference(line_node, code)
           if line_diff.zero?
             add_offense_for_same_line(node, line_node)
@@ -227,7 +227,7 @@ module RuboCop
         end
 
         def missing_line(node, code)
-          line_diff = line_difference(node.arguments.last, code)
+          line_diff = line_difference(node.last_argument, code)
           sign = line_diff.positive? ? :+ : :-
           expected_line(sign, line_diff)
         end

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/explicit_block_argument.rb

@@ -86,7 +86,7 @@ module RuboCop
 
         def extract_block_name(def_node)
           if def_node.block_argument?
-            def_node.arguments.last.name
+            def_node.last_argument.name
           else
             'block'
           end
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def insert_argument(node, corrector, block_name)
-          last_arg = node.arguments.last
+          last_arg = node.last_argument
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
           replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')

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

@@ -17,10 +17,16 @@ module RuboCop
       # @example
       #   # bad
       #   hash.keys.each { |k| p k }
-      #   hash.values.each { |v| p v }
+      #   hash.each { |k, unused_value| p k }
       #
       #   # good
       #   hash.each_key { |k| p k }
+      #
+      #   # bad
+      #   hash.values.each { |v| p v }
+      #   hash.each { |unused_key, v| p v }
+      #
+      #   # good
       #   hash.each_value { |v| p v }
       #
       # @example AllowedReceivers: ['execute']
@@ -33,22 +39,46 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method each_arguments(node)
+        def_node_matcher :each_arguments, <<~PATTERN
+          (block (call _ :each)(args $_key $_value) ...)
         PATTERN
 
         # @!method kv_each_with_block_pass(node)
         def_node_matcher :kv_each_with_block_pass, <<~PATTERN
-          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
+          (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_block(node)
+          return unless handleable?(node)
+
           kv_each(node) do |target, method|
-            register_kv_offense(target, method)
+            register_kv_offense(target, method) and return
+          end
+
+          return unless (key, value = each_arguments(node))
+
+          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)
+            message = message('each_value', node.method_name, key.source)
+            unused_range = key.source_range.begin.join(value.source_range.begin)
+
+            register_each_args_offense(node, message, 'each_value', unused_range)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
 
@@ -60,27 +90,70 @@ 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)
 
-          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+          current = target.receiver.loc.selector.join(target.source_range.end).source
+
+          add_offense(kv_range(target), message: format_message(method, current)) do |corrector|
             correct_key_value_each(target, corrector)
           end
         end
 
+        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).all? do |block_arg|
+              lvar_sources.none?(block_arg.source)
+            end
+          else
+            lvar_sources.none?(block_arg.source)
+          end
+        end
+
+        def message(prefer, method_name, unused_code)
+          format(
+            UNUSED_BLOCK_ARG_MSG, prefer: prefer, current: method_name, unused_code: unused_code
+          )
+        end
+
+        def register_each_args_offense(node, message, prefer, unused_range)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.send_node.loc.selector, prefer)
+            corrector.remove(unused_range)
+          end
+        end
+
         def register_kv_with_block_pass_offense(node, target, method)
           return unless (parent_receiver = node.parent.receiver.receiver)
           return if allowed_receiver?(parent_receiver)
 
-          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
-          add_offense(range, message: format_message(method)) do |corrector|
+          range = target.loc.selector.join(node.parent.loc.selector.end)
+
+          add_offense(range, message: format_message(method, range.source)) do |corrector|
             corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
-        def format_message(method_name)
-          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        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
 
         def check_argument(variable)
@@ -103,7 +176,7 @@ module RuboCop
           name = "each_#{node.receiver.method_name.to_s.chop}"
           return correct_implicit(node, corrector, name) unless receiver
 
-          new_source = receiver.source + ".#{name}"
+          new_source = receiver.source + "#{node.loc.dot.source}#{name}"
           corrector.replace(node, new_source)
         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/inverse_methods.rb

@@ -60,17 +60,17 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+          ({block numblock} $(call (...) $_) ... { $(call ... :!)
                                                    $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(call ... :!))
                                                    (begin ... $(send (...) {:!= :!~} ...))
                                                  })
         PATTERN
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|

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

@@ -34,21 +34,25 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        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
           {
-            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
-            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
         def on_send(node)
           return unless (to_h_node, map_node = map_to_h?(node))
 
-          message = format(MSG, method: map_node.loc.selector.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: map_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
@@ -56,6 +60,7 @@ module RuboCop
             autocorrect(corrector, to_h_node, map_node)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -63,6 +68,7 @@ module RuboCop
           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))
+          corrector.replace(map.loc.dot, '.') if to_h.dot?
           corrector.replace(map.loc.selector, 'to_h')
         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) ||

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

@@ -239,7 +239,7 @@ module RuboCop
         def args_parenthesized?(node)
           return false unless node.arguments.one?
 
-          first_node = node.arguments.first
+          first_node = node.first_argument
           first_node.begin_type? && first_node.parenthesized_call?
         end
       end

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/method_def_parentheses.rb

@@ -170,7 +170,7 @@ module RuboCop
           return true if node.arguments.any? do |arg|
             arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
           end
-          return false unless (last_argument = node.arguments.last)
+          return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # defining `respond_to_missing?`.
       #
       # @example
-      #   #bad
+      #   # bad
       #   def method_missing(name, *args)
       #     # ...
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
       #     # ...
       #   end

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/operator_method_call.rb

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks for redundant dot before operator method call.
-      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
-      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      # The target operator methods are `|`, `^`, `&`, ``<=>``, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # ``<=``, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
       #
       # @example
       #

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

@@ -67,12 +67,13 @@ module RuboCop
           return unless redundant_argument?(node)
 
           offense_range = argument_range(node)
-          message = format(MSG, arg: node.arguments.first.source)
+          message = format(MSG, arg: node.first_argument.source)
 
           add_offense(offense_range, message: message) do |corrector|
             corrector.remove(offense_range)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -80,7 +81,7 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.arguments.first == redundant_argument
+          node.first_argument == redundant_argument
         end
 
         def redundant_arg_for_method(method_name)

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

@@ -25,20 +25,20 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
           return unless parent.call_type? || parent.kwsplat_type?
           return unless mergeable?(parent)
           return unless (kwsplat = node.each_ancestor(:kwsplat).first)
-          return if allowed_double_splat_receiver?(kwsplat)
+          return if !node.braces? || allowed_double_splat_receiver?(kwsplat)
 
           add_offense(kwsplat) do |corrector|
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method redundant_fetch_block_candidate?(node)
         def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
           (block
-            $(send _ :fetch _)
+            $(call _ :fetch _)
             (args)
             ${nil? #basic_literal? #const_type?})
         PATTERN
@@ -61,10 +61,10 @@ module RuboCop
             bad = build_bad_method(send, body)
 
             add_offense(range, message: format(MSG, good: good, bad: bad)) do |corrector|
-              receiver, _, key = send.children
+              _, _, key = send.children
               default_value = body ? body.source : 'nil'
 
-              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
+              corrector.replace(range, "fetch(#{key.source}, #{default_value})")
             end
           end
         end

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

@@ -107,6 +107,8 @@ module RuboCop
 
         def inside_string_literal_or_method_with_argument?(range)
           processed_source.tokens.each_cons(2).any? do |token, next_token|
+            next if token.line == next_token.line
+
             inside_string_literal?(range, token) || method_with_argument?(token, next_token)
           end
         end