Handle inject(&:+) in Performance/Sum

CHANGELOG.md

@@ -10,6 +10,7 @@
 ### Changes
 
 * [#163](https://github.com/rubocop-hq/rubocop-performance/pull/163): Change `Performance/Detect` to also detect offenses when index 0 or -1 is used instead (ie. `detect{ ... }[0]`). ([@dvandersluis][])
+* [#168](https://github.com/rubocop-hq/rubocop-performance/pull/168): Extend `Performance/Sum` to register an offense for `inject(&:+)`. ([@eugeneius][])
 
 ## 1.8.0 (2020-09-04)
 

docs/modules/ROOT/pages/cops_performance.adoc

@@ -1649,6 +1649,7 @@ in some Enumerable object can be replaced by `Enumerable#sum` method.
 # bad
 [1, 2, 3].inject(:+)
 [1, 2, 3].reduce(10, :+)
+[1, 2, 3].inject(&:+)
 [1, 2, 3].reduce { |acc, elem| acc + elem }
 
 # good

lib/rubocop/cop/performance/sum.rb

@@ -10,6 +10,7 @@ module Performance
  # # bad
  # [1, 2, 3].inject(:+)
  # [1, 2, 3].reduce(10, :+)
+ # [1, 2, 3].inject(&:+)
  # [1, 2, 3].reduce { |acc, elem| acc + elem }
  #
  # # good
@@ -24,7 +25,7 @@ class Sum < Base
  MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
 
  def_node_matcher :sum_candidate?, <<~PATTERN
- (send _ ${:inject :reduce} $_init ? (sym :+))
+ (send _ ${:inject :reduce} $_init ? ${(sym :+) (block_pass (sym :+))})
  PATTERN
 
  def_node_matcher :sum_with_block_candidate?, <<~PATTERN
@@ -40,9 +41,9 @@ class Sum < Base
  alias elem_plus_acc? acc_plus_elem?
 
  def on_send(node)
- sum_candidate?(node) do |method, init|
+ sum_candidate?(node) do |method, init, operation|
  range = sum_method_range(node)
- message = build_method_message(method, init)
+ message = build_method_message(method, init, operation)
 
  add_offense(range, message: message) do |corrector|
  autocorrect(corrector, init, range)
@@ -81,9 +82,9 @@ def sum_block_range(send, node)
  range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
  end
 
- def build_method_message(method, init)
+ def build_method_message(method, init, operation)
  good_method = build_good_method(init)
- bad_method = build_method_bad_method(init, method)
+ bad_method = build_method_bad_method(init, method, operation)
  format(MSG, good_method: good_method, bad_method: bad_method)
  end
 
@@ -103,13 +104,17 @@ def build_good_method(init)
  good_method
  end
 
- def build_method_bad_method(init, method)
+ def build_method_bad_method(init, method, operation)
  bad_method = "#{method}("
  unless init.empty?
  init = init.first
  bad_method += "#{init.source}, "
  end
- bad_method += ':+)'
+ bad_method += if operation.block_pass_type?
+ '&:+)'
+ else
+ ':+)'
+ end
  bad_method
  end
 

spec/rubocop/cop/performance/sum_spec.rb

@@ -70,7 +70,7 @@
  RUBY
  end
 
- it 'does not autocorrect when initial value is not provided' do
+ it 'does not autocorrect `:+` when initial value is not provided' do
  expect_offense(<<~RUBY, method: method)
  array.#{method}(:+)
  ^{method}^^^^ Use `sum` instead of `#{method}(:+)`.
@@ -79,6 +79,26 @@
  expect_no_corrections
  end
 
+ it "registers an offense and corrects when using `array.#{method}(0, &:+)`" do
+ expect_offense(<<~RUBY, method: method)
+ array.#{method}(0, &:+)
+ ^{method}^^^^^^^^ Use `sum` instead of `#{method}(0, &:+)`.
+ RUBY
+
+ expect_correction(<<~RUBY)
+ array.sum
+ RUBY
+ end
+
+ it 'does not autocorrect `&:+` when initial value is not provided' do
+ expect_offense(<<~RUBY, method: method)
+ array.#{method}(&:+)
+ ^{method}^^^^^ Use `sum` instead of `#{method}(&:+)`.
+ RUBY
+
+ expect_no_corrections
+ end
+
  it 'does not register an offense when block does not implement summation' do
  expect_no_offenses(<<~RUBY)
  array.#{method} { |acc, elem| elem * 2 }