Merge pull request #488 from Earlopain/collection-literal-ruby34

koic · web-flow · commit eb68f9632b7c · 2025-02-27T15:33:09.000+09:00
Change `Performance/CollectionLiteralInLoop` to not register offenses for `Array#include?` that are optimized directly in Ruby.
diff --git a/changelog/change_collection_literal_include_ruby34.md b/changelog/change_collection_literal_include_ruby34.md
@@ -0,0 +1 @@
+* [#482](https://github.com/rubocop/rubocop-performance/issues/482): Change `Performance/CollectionLiteralInLoop` to not register offenses for `Array#include?` that are optimized directly in Ruby. ([@earlopain][])
diff --git a/lib/rubocop/cop/performance/collection_literal_in_loop.rb b/lib/rubocop/cop/performance/collection_literal_in_loop.rb
@@ -12,6 +12,14 @@ module Performance
       # You can set the minimum number of elements to consider
       # an offense with `MinSize`.
       #
+      # NOTE: Since Ruby 3.4, certain simple arguments to `Array#include?` are
+      # optimized directly in Ruby. This avoids allocations without changing the
+      # code, as such no offense will be registered in those cases. Currently that
+      # includes: strings, `self`, local variables, instance variables, and method
+      # calls without arguments. Additionally, any number of methods can be chained:
+      # `[1, 2, 3].include?(@foo)` and `[1, 2, 3].include?(@foo.bar.baz)` both avoid
+      # the array allocation.
+      #
       # @example
       #   # bad
       #   users.select do |user|
@@ -55,6 +63,8 @@ class CollectionLiteralInLoop < Base
 
         ARRAY_METHODS = (ENUMERABLE_METHOD_NAMES | NONMUTATING_ARRAY_METHODS).to_set.freeze
 
+        ARRAY_INCLUDE_OPTIMIZED_TYPES = %i[str self lvar ivar send].freeze
+
         NONMUTATING_HASH_METHODS = %i[< <= == > >= [] any? assoc compact dig
                                       each each_key each_pair each_value empty?
                                       eql? fetch fetch_values filter flatten has_key?
@@ -80,21 +90,42 @@ class CollectionLiteralInLoop < Base
         PATTERN
 
         def on_send(node)
-          receiver, method, = *node.children
-          return unless check_literal?(receiver, method) && parent_is_loop?(receiver)
+          receiver, method, *arguments = *node.children
+          return unless check_literal?(receiver, method, arguments) && parent_is_loop?(receiver)
 
           message = format(MSG, literal_class: literal_class(receiver))
           add_offense(receiver, message: message)
         end
 
         private
 
-        def check_literal?(node, method)
+        def check_literal?(node, method, arguments)
           !node.nil? &&
             nonmutable_method_of_array_or_hash?(node, method) &&
             node.children.size >= min_size &&
-            node.recursive_basic_literal?
+            node.recursive_basic_literal? &&
+            !optimized_array_include?(node, method, arguments)
+        end
+
+        # Since Ruby 3.4, simple arguments to Array#include? are optimized.
+        # See https://github.com/ruby/ruby/pull/12123 for more details.
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def optimized_array_include?(node, method, arguments)
+          return false unless target_ruby_version >= 3.4 && node.array_type? && method == :include?
+          # Disallow include?(1, 2)
+          return false if arguments.count != 1
+
+          arg = arguments.first
+          # Allow `include?(foo.bar.baz.bat)`
+          while arg.send_type?
+            return false if arg.arguments.any? # Disallow include?(foo(bar))
+            break unless arg.receiver
+
+            arg = arg.receiver
+          end
+          ARRAY_INCLUDE_OPTIMIZED_TYPES.include?(arg.type)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def nonmutable_method_of_array_or_hash?(node, method)
           (node.array_type? && ARRAY_METHODS.include?(method)) ||
diff --git a/spec/rubocop/cop/performance/collection_literal_in_loop_spec.rb b/spec/rubocop/cop/performance/collection_literal_in_loop_spec.rb
@@ -269,4 +269,71 @@
       RUBY
     end
   end
+
+  context 'when Ruby >= 3.4', :ruby34 do
+    it 'registers an offense for `include?` on a Hash literal' do
+      expect_offense(<<~RUBY)
+        each do
+          { foo: :bar }.include?(:foo)
+          ^^^^^^^^^^^^^ Avoid immutable Hash literals in loops. It is better to extract it into a local variable or a constant.
+        end
+      RUBY
+    end
+
+    it 'registers an offense for other array methods' do
+      expect_offense(<<~RUBY)
+        each do
+          [1, 2, 3].index(foo)
+          ^^^^^^^^^ Avoid immutable Array literals in loops. It is better to extract it into a local variable or a constant.
+        end
+      RUBY
+    end
+
+    context 'when using an Array literal and calling `include?`' do
+      [
+        '"string"',
+        'self',
+        'local_variable',
+        'method_call',
+        '@instance_variable'
+      ].each do |argument|
+        it "registers no offense when the argument is #{argument}" do
+          expect_no_offenses(<<~RUBY)
+            #{'local_variable = 123' if argument == 'local_variable'}
+            array.all? do |e|
+              [1, 2, 3].include?(#{argument})
+            end
+          RUBY
+        end
+
+        it "registers no offense when the argument is #{argument} with method chain" do
+          expect_no_offenses(<<~RUBY)
+            #{'local_variable = 123' if argument == 'local_variable'}
+            array.all? do |e|
+              [1, 2, 3].include?(#{argument}.call)
+            end
+          RUBY
+        end
+
+        it "registers no offense when the argument is #{argument} with double method chain" do
+          expect_no_offenses(<<~RUBY)
+            #{'local_variable = 123' if argument == 'local_variable'}
+            array.all? do |e|
+              [1, 2, 3].include?(#{argument}.call.call)
+            end
+          RUBY
+        end
+
+        it "registers an offense when the argument is #{argument} with method chain and arguments" do
+          expect_offense(<<~RUBY)
+            #{'local_variable = 123' if argument == 'local_variable'}
+            array.all? do |e|
+              [1, 2, 3].include?(#{argument}.call(true))
+              ^^^^^^^^^ Avoid immutable Array literals in loops. It is better to extract it into a local variable or a constant.
+            end
+          RUBY
+        end
+      end
+    end
+  end
 end

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+* [#482](https://github.com/rubocop/rubocop-performance/issues/482): Change `Performance/CollectionLiteralInLoop` to not register offenses for `Array#include?` that are optimized directly in Ruby. ([@earlopain][])