rubocop-performance 1.18.0 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4926be80598b4880037ffd36eef32c9025051af7f0398f69a34439c135c9d87
-  data.tar.gz: ba3d738da529cbc70c33e8c5d4baa4c6c8013a5498c834f2e28dc87a8811c15a
+  metadata.gz: c00ee718f283199f3c4f53b54071998b356f7239edcd3c84015bac94ad1b05dc
+  data.tar.gz: a5e7d011cd090fd5d30eb0ef9e12acabb93a993cc3acb46129da46c37294e1ba
 SHA512:
-  metadata.gz: 1b9a64379554a660c30bffea5a0fc8a8d36a9e31efef6ccb4576f4df432d2f270d91d76b0e7e7638740e6cf83a50b94b4dfe37d93e5366d0171b8a0f4e5bff50
-  data.tar.gz: d27b9db647eb1a53f3e80b0ec20cd43b37b0244127a28f7fbdacefcf9477205a7f4d373c0a27d882fcb43f902d4ab398ad73ea3f51cdd21e5d422cd419d621e9
+  metadata.gz: 711efd2eae8c54dc1b567e198360038fb16eee00c2e6a61db7dbcfb063f219618e36809ac5679cc531e8fe84245ea1f66e6e8eb9fbed5cbb9dcc22f57c10dab6
+  data.tar.gz: 5618f678392ffb6f93b34388e3ef060c017f7e70b53d992ebe48d2bb49b7ec5570adc7b21f5f22f0511cddc4fb1dead044904d7bcf40949191ee6ed8b884565f

data/README.md

@@ -53,6 +53,8 @@ $ rubocop --require rubocop-performance
 ### Rake task
 
 ```ruby
+require 'rubocop/rake_task'
+
 RuboCop::RakeTask.new do |task|
   task.requires << 'rubocop-performance'
 end

data/config/default.yml

@@ -6,7 +6,7 @@ Performance:
 
 Performance/AncestorsInclude:
   Description: 'Use `A <= B` instead of `A.ancestors.include?(B)`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code'
+  Reference: 'https://github.com/fastruby/fast-ruby#ancestorsinclude-vs--code'
   Enabled: 'pending'
   Safe: false
   VersionAdded: '1.7'
@@ -54,10 +54,11 @@ Performance/CaseWhenSplat:
 Performance/Casecmp:
   Description: >-
              Use `casecmp` rather than `downcase ==`, `upcase ==`, `== downcase`, or `== upcase`..
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code'
-  Enabled: true
+  Reference: 'https://github.com/fastruby/fast-ruby#stringcasecmp-vs--stringcasecmp-vs-stringdowncase---code'
+  Enabled: false
   Safe: false
   VersionAdded: '0.36'
+  VersionChanged: '1.21'
 
 Performance/ChainArrayAllocation:
   Description: >-
@@ -122,7 +123,7 @@ Performance/Detect:
   Description: >-
                   Use `detect` instead of `select.first`, `find_all.first`, `filter.first`,
                   `select.last`, `find_all.last`, and `filter.last`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
   # This cop has known compatibility issues with `ActiveRecord` and other
   # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
   # has its own meaning. Correcting `ActiveRecord` methods with this cop
@@ -145,7 +146,7 @@ Performance/DoubleStartEndWith:
 
 Performance/EndWith:
   Description: 'Use `end_with?` instead of a regex match anchored to the end of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringmatch-vs-stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
   # This will change to a new method call which isn't guaranteed to be on the
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
@@ -165,7 +166,7 @@ Performance/FlatMap:
                   Use `Enumerable#flat_map`
                   instead of `Enumerable#map...Array#flatten(1)`
                   or `Enumerable#collect..Array#flatten(1)`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
   Enabled: true
   VersionAdded: '0.30'
   EnabledForFlattenWithoutParams: false
@@ -176,7 +177,7 @@ Performance/FlatMap:
 
 Performance/InefficientHashSearch:
   Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
   Enabled: true
   VersionAdded: '0.56'
   Safe: false
@@ -193,9 +194,15 @@ Performance/MapCompact:
   SafeAutoCorrect: false
   VersionAdded: '1.11'
 
+Performance/MapMethodChain:
+  Description: 'Checks if the `map` method is used in a chain.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '1.19'
+
 Performance/MethodObjectAsBlock:
   Description: 'Use block explicitly instead of block-passing a method object.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#normal-way-to-apply-method-vs-method-code'
   Enabled: pending
   VersionAdded: '1.9'
 
@@ -207,7 +214,7 @@ Performance/OpenStruct:
 
 Performance/RangeInclude:
   Description: 'Use `Range#cover?` instead of `Range#include?` (or `Range#member?`).'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#cover-vs-include-code'
   Enabled: true
   VersionAdded: '0.36'
   VersionChanged: '1.7'
@@ -215,7 +222,7 @@ Performance/RangeInclude:
 
 Performance/RedundantBlockCall:
   Description: 'Use `yield` instead of `block.call`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
+  Reference: 'https://github.com/fastruby/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
   Enabled: true
   VersionAdded: '0.36'
 
@@ -238,7 +245,7 @@ Performance/RedundantMatch:
 
 Performance/RedundantMerge:
   Description: 'Use Hash#[]=, rather than Hash#merge! with a single key-value pair.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#hashmerge-vs-hash-code'
   Enabled: true
   Safe: false
   VersionAdded: '0.36'
@@ -265,13 +272,13 @@ Performance/RegexpMatch:
   Description: >-
                   Use `match?` instead of `Regexp#match`, `String#match`, `Symbol#match`,
                   `Regexp#===`, or `=~` when `MatchData` is not used.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-'
+  Reference: 'https://github.com/fastruby/fast-ruby#regexp-vs-regexpmatch-vs-regexpmatch-vs-stringmatch-vs-string-vs-stringmatch-code-'
   Enabled: true
   VersionAdded: '0.47'
 
 Performance/ReverseEach:
   Description: 'Use `reverse_each` instead of `reverse.each`.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
   Enabled: true
   VersionAdded: '0.30'
 
@@ -289,7 +296,7 @@ Performance/Size:
   Description: >-
                   Use `size` instead of `count` for counting
                   the number of elements in `Array` and `Hash`.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
   Enabled: true
   VersionAdded: '0.30'
 
@@ -300,13 +307,13 @@ Performance/SortReverse:
 
 Performance/Squeeze:
   Description: "Use `squeeze('a')` instead of `gsub(/a+/, 'a')`."
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code'
   Enabled: 'pending'
   VersionAdded: '1.7'
 
 Performance/StartWith:
   Description: 'Use `start_with?` instead of a regex match anchored to the beginning of a string.'
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringmatch-vs-stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
   # This will change to a new method call which isn't guaranteed to be on the
   # object. Switching these methods has to be done with knowledge of the types
   # of the variables which rubocop doesn't have.
@@ -333,7 +340,7 @@ Performance/StringReplacement:
                   Use `tr` instead of `gsub` when you are replacing the same
                   number of characters. Use `delete` instead of `gsub` when
                   you are deleting characters.
-  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code'
+  Reference: 'https://github.com/fastruby/fast-ruby#stringgsub-vs-stringtr-code'
   Enabled: true
   VersionAdded: '0.33'
 

data/lib/rubocop/cop/mixin/sort_block.rb

@@ -9,14 +9,14 @@ module RuboCop
 
       def_node_matcher :sort_with_block?, <<~PATTERN
         (block
-          $(send _ :sort)
+          $(call _ :sort)
           (args (arg $_a) (arg $_b))
           $send)
       PATTERN
 
       def_node_matcher :sort_with_numblock?, <<~PATTERN
         (numblock
-          $(send _ :sort)
+          $(call _ :sort)
           $_arg_count
           $send)
       PATTERN

data/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb

@@ -39,7 +39,7 @@ module RuboCop
         RESTRICT_ON_SEND = SLICE_METHODS
 
         def_node_matcher :endless_range_slice?, <<~PATTERN
-          (send $_ $%SLICE_METHODS $#endless_range?)
+          (call $!{str dstr xstr} $%SLICE_METHODS $#endless_range?)
         PATTERN
 
         def_node_matcher :endless_range?, <<~PATTERN
@@ -59,6 +59,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/block_given_with_explicit_block.rb

@@ -47,6 +47,10 @@ module RuboCop
             corrector.replace(node, block_arg_name)
           end
         end
+
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/casecmp.rb

@@ -6,6 +6,12 @@ module RuboCop
       # Identifies places where a case-insensitive string comparison
       # can better be implemented using `casecmp`.
       #
+      # This cop is disabled by default because `String#casecmp` only works with
+      # ASCII characters. See https://github.com/rubocop/rubocop/issues/9753.
+      #
+      # If you are working only with ASCII characters, then this cop can be
+      # safely enabled.
+      #
       # @safety
       #   This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
       #   differently when using Non-ASCII characters.

data/lib/rubocop/cop/performance/chain_array_allocation.rb

@@ -19,8 +19,6 @@ module RuboCop
       #   array.map! { |x| x.downcase }
       #   array
       class ChainArrayAllocation < Base
-        include RangeHelp
-
         # These methods return a new array but only sometimes. They must be
         # called with an argument. For example:
         #
@@ -54,7 +52,7 @@ module RuboCop
         def_node_matcher :chain_array_allocation?, <<~PATTERN
           (send {
             (send _ $%RETURN_NEW_ARRAY_WHEN_ARGS {int lvar ivar cvar gvar send})
-            (block (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
+            ({block numblock} (send _ $%ALWAYS_RETURNS_NEW_ARRAY) ...)
             (send _ $%RETURNS_NEW_ARRAY ...)
           } $%HAS_MUTATION_ALTERNATIVE ...)
         PATTERN
@@ -62,12 +60,21 @@ module RuboCop
         def on_send(node)
           chain_array_allocation?(node) do |fm, sm|
             return if node.each_descendant(:send).any? { |descendant| descendant.method?(:lazy) }
+            return if node.method?(:select) && !enumerable_select_method?(node.receiver)
 
-            range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+            range = node.loc.selector.begin.join(node.source_range.end)
 
             add_offense(range, message: format(MSG, method: fm, second_method: sm))
           end
         end
+
+        private
+
+        def enumerable_select_method?(node)
+          # NOTE: `QueryMethods#select` in Rails accepts positional arguments, whereas `Enumerable#select` does not.
+          #        This difference can be utilized to reduce the knowledge requirements related to `select`.
+          (node.block_type? || node.numblock_type?) && node.send_node.arguments.empty?
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/count.rb

@@ -9,8 +9,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
-      #   frameworks. ActiveRecord's `count` ignores the block that is passed to it.
-      #   `ActiveRecord` will ignore the block that is passed to `count`.
+      #   frameworks. Before Rails 5.1, `ActiveRecord` will ignore the block that is passed to `count`.
       #   Other methods, such as `select`, will convert the association to an
       #   array and then run the block on the array. A simple work around to
       #   make `count` work with a block is to call `to_a.count {...}`.
@@ -55,8 +54,8 @@ module RuboCop
 
         def_node_matcher :count_candidate?, <<~PATTERN
           {
-            (send (block $(send _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
-            (send $(send _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
+            (call (block $(call _ ${:select :filter :find_all :reject}) ...) ${:count :length :size})
+            (call $(call _ ${:select :filter :find_all :reject} (:block_pass _)) ${:count :length :size})
           }
         PATTERN
 
@@ -73,6 +72,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -101,7 +101,7 @@ module RuboCop
         end
 
         def negate_reject(corrector, node)
-          if node.receiver.send_type?
+          if node.receiver.call_type?
             negate_block_pass_reject(corrector, node)
           else
             negate_block_reject(corrector, node)

data/lib/rubocop/cop/performance/delete_prefix.rb

@@ -64,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_prefix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_start?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_prefix_candidate?(node))
           return unless replace_string.empty?
@@ -80,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/performance/delete_suffix.rb

@@ -64,9 +64,10 @@ module RuboCop
         }.freeze
 
         def_node_matcher :delete_suffix_candidate?, <<~PATTERN
-          (send $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
+          (call $!nil? ${:gsub :gsub! :sub :sub!} (regexp (str $#literal_at_end?) (regopt)) (str $_))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless (receiver, bad_method, regexp_str, replace_string = delete_suffix_candidate?(node))
           return unless replace_string.empty?
@@ -80,11 +81,13 @@ module RuboCop
             regexp_str = interpret_string_escapes(regexp_str)
             string_literal = to_string_literal(regexp_str)
 
-            new_code = "#{receiver.source}.#{good_method}(#{string_literal})"
+            new_code = "#{receiver.source}#{node.loc.dot.source}#{good_method}(#{string_literal})"
 
             corrector.replace(node, new_code)
           end
         end
+        # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/performance/detect.rb

@@ -40,9 +40,9 @@ module RuboCop
 
         def_node_matcher :detect_candidate?, <<~PATTERN
           {
-            (send $(block (send _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
+            (send $(block (call _ %CANDIDATE_METHODS) ...) ${:first :last} $...)
             (send $(block (send _ %CANDIDATE_METHODS) ...) $:[] (int ${0 -1}))
-            (send $(send _ %CANDIDATE_METHODS ...) ${:first :last} $...)
+            (send $(call _ %CANDIDATE_METHODS ...) ${:first :last} $...)
             (send $(send _ %CANDIDATE_METHODS ...) $:[] (int ${0 -1}))
           }
         PATTERN
@@ -63,6 +63,7 @@ module RuboCop
             register_offense(node, receiver, second_method, index)
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/end_with.rb

@@ -54,9 +54,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[match =~ match?].freeze
 
         def_node_matcher :redundant_regex?, <<~PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
+          {(call $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :match?} $_)
-           (match-with-lvasgn (regexp (str $#literal_at_end?) (regopt)) $_)}
+           ({send match-with-lvasgn} (regexp (str $#literal_at_end?) (regopt)) $_)
+           (send (regexp (str $#literal_at_end?) (regopt)) :=~ $_)}
         PATTERN
 
         def on_send(node)
@@ -66,12 +67,14 @@ module RuboCop
             receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
             regex_str = drop_end_metacharacter(regex_str)
             regex_str = interpret_string_escapes(regex_str)
+            dot = node.loc.dot ? node.loc.dot.source : '.'
 
-            new_source = "#{receiver.source}.end_with?(#{to_string_literal(regex_str)})"
+            new_source = "#{receiver.source}#{dot}end_with?(#{to_string_literal(regex_str)})"
 
             corrector.replace(node, new_source)
           end
         end
+        alias on_csend on_send
         alias on_match_with_lvasgn on_send
       end
     end

data/lib/rubocop/cop/performance/fixed_size.rb

@@ -50,7 +50,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[count length size].freeze
 
         def_node_matcher :counter, <<~MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
+          (call ${array hash str sym} {:count :length :size} $...)
         MATCHER
 
         def on_send(node)
@@ -62,6 +62,7 @@ module RuboCop
             add_offense(node)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -78,13 +79,13 @@ module RuboCop
         end
 
         def contains_splat?(node)
-          return unless node.array_type?
+          return false unless node.array_type?
 
           node.each_child_node(:splat).any?
         end
 
         def contains_double_splat?(node)
-          return unless node.hash_type?
+          return false unless node.hash_type?
 
           node.each_child_node(:kwsplat).any?
         end

data/lib/rubocop/cop/performance/flat_map.rb

@@ -26,10 +26,10 @@ module RuboCop
                                   'multiple levels.'
 
         def_node_matcher :flat_map_candidate?, <<~PATTERN
-          (send
+          (call
             {
-              $(block (send _ ${:collect :map}) ...)
-              $(send _ ${:collect :map} (block_pass _))
+              $(block (call _ ${:collect :map}) ...)
+              $(call _ ${:collect :map} (block_pass _))
             }
             ${:flatten :flatten!}
             $...
@@ -46,6 +46,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -45,7 +45,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[include?].freeze
 
         def_node_matcher :inefficient_include?, <<~PATTERN
-          (send (send $_ {:keys :values}) :include? _)
+          (call (call $_ {:keys :values}) :include? _)
         PATTERN
 
         def on_send(node)
@@ -56,21 +56,23 @@ module RuboCop
             add_offense(node, message: message) do |corrector|
               # Replace `keys.include?` or `values.include?` with the appropriate
               # `key?`/`value?` method.
-              corrector.replace(
-                node,
-                "#{autocorrect_hash_expression(node)}.#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-              )
+              corrector.replace(node, replacement(node))
             end
           end
         end
+        alias on_csend on_send
 
         private
 
         def message(node)
-          "Use `##{autocorrect_method(node)}` instead of `##{current_method(node)}.include?`."
+          "Use `##{correct_method(node)}` instead of `##{current_method(node)}.include?`."
         end
 
-        def autocorrect_method(node)
+        def replacement(node)
+          "#{correct_hash_expression(node)}#{correct_dot(node)}#{correct_method(node)}(#{correct_argument(node)})"
+        end
+
+        def correct_method(node)
           case current_method(node)
           when :keys then use_long_method ? 'has_key?' : 'key?'
           when :values then use_long_method ? 'has_value?' : 'value?'
@@ -86,13 +88,17 @@ module RuboCop
           preferred_config && preferred_config['EnforcedStyle'] == 'long' && preferred_config['Enabled']
         end
 
-        def autocorrect_argument(node)
-          node.arguments.first.source
+        def correct_argument(node)
+          node.first_argument.source
         end
 
-        def autocorrect_hash_expression(node)
+        def correct_hash_expression(node)
           node.receiver.receiver.source
         end
+
+        def correct_dot(node)
+          node.receiver.loc.dot.source
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/map_compact.rb

@@ -39,13 +39,13 @@ module RuboCop
 
         def_node_matcher :map_compact, <<~PATTERN
           {
-            (send
-              $(send _ {:map :collect}
+            (call
+              $(call _ {:map :collect}
                 (block_pass
                   (sym _))) _)
-            (send
+            (call
               (block
-                $(send _ {:map :collect})
+                $(call _ {:map :collect})
                   (args ...) _) _)
           }
         PATTERN
@@ -61,6 +61,7 @@ module RuboCop
             remove_compact_method(corrector, map_node, node, node.parent)
           end
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/performance/map_method_chain.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # Checks if the map method is used in a chain.
+      #
+      # Autocorrection is not supported because an appropriate block variable name cannot be determined automatically.
+      #
+      # @safety
+      #   This cop is unsafe because false positives occur if the number of times the first method is executed
+      #   affects the return value of subsequent methods.
+      #
+      # [source,ruby]
+      # ----
+      # class X
+      #   def initialize
+      #     @@num = 0
+      #   end
+      #
+      #   def foo
+      #     @@num += 1
+      #     self
+      #   end
+      #
+      #   def bar
+      #     @@num * 2
+      #   end
+      # end
+      #
+      # [X.new, X.new].map(&:foo).map(&:bar) # => [4, 4]
+      # [X.new, X.new].map { |x| x.foo.bar } # => [2, 4]
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   array.map(&:foo).map(&:bar)
+      #
+      #   # good
+      #   array.map { |item| item.foo.bar }
+      #
+      class MapMethodChain < Base
+        include IgnoredNode
+
+        MSG = 'Use `%<method_name>s { |x| x.%<map_args>s }` instead of `%<method_name>s` method chain.'
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def_node_matcher :block_pass_with_symbol_arg?, <<~PATTERN
+          (:block_pass (:sym $_))
+        PATTERN
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+          return unless (map_arg = block_pass_with_symbol_arg?(node.first_argument))
+
+          map_args = [map_arg]
+
+          return unless (begin_of_chained_map_method = find_begin_of_chained_map_method(node, map_args))
+
+          range = begin_of_chained_map_method.loc.selector.begin.join(node.source_range.end)
+          message = format(MSG, method_name: begin_of_chained_map_method.method_name, map_args: map_args.join('.'))
+
+          add_offense(range, message: message)
+
+          ignore_node(node)
+        end
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def find_begin_of_chained_map_method(node, map_args)
+          return unless (chained_map_method = node.receiver)
+          return if !chained_map_method.call_type? || !RESTRICT_ON_SEND.include?(chained_map_method.method_name)
+          return unless (map_arg = block_pass_with_symbol_arg?(chained_map_method.first_argument))
+
+          map_args.unshift(map_arg)
+
+          receiver = chained_map_method.receiver
+
+          return chained_map_method unless receiver&.call_type? && block_pass_with_symbol_arg?(receiver.first_argument)
+
+          find_begin_of_chained_map_method(chained_map_method, map_args)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end