rubocop 1.81.7 → 1.92.1

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

@@ -142,7 +142,8 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token&.text&.valid_encoding? && Encoding::ENCODING_PATTERN.match?(next_token.text)
+          if next_token&.text&.valid_encoding? &&
+             MagicComment.parse(next_token.text).encoding_specified?
             token = next_token
           end
 

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

@@ -3,7 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of global variables.
+      # Looks for uses of global variables. Global variables introduce
+      # shared mutable state that makes code harder to test, debug,
+      # and reason about, since any part of the program can read or modify them.
+      #
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.
@@ -54,7 +57,7 @@ module RuboCop
         ].map(&:to_sym)
 
         def user_vars
-          cop_config['AllowedVariables'].map(&:to_sym)
+          @user_vars ||= cop_config['AllowedVariables'].map(&:to_sym).freeze
         end
 
         def allowed_var?(global_var)

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

@@ -45,17 +45,6 @@ module RuboCop
       #   ok
       #
       #   # bad
-      #   if something
-      #     foo || raise('exception')
-      #   else
-      #     ok
-      #   end
-      #
-      #   # good
-      #   foo || raise('exception') if something
-      #   ok
-      #
-      #   # bad
       #   define_method(:test) do
       #     if something
       #       work
@@ -120,6 +109,10 @@ module RuboCop
         MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
               'code inside a conditional expression.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MissingElse]
+        end
+
         def on_def(node)
           body = node.body
 
@@ -193,57 +186,73 @@ module RuboCop
             return if trivial?(node)
 
             example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
-            replacement = <<~RUBY.chomp
-              #{conditional_keyword} #{condition.source}
-                #{scope_exiting_keyword}
-              end
-            RUBY
+            replacement = "#{conditional_keyword} #{condition.source}\n  #{scope_exiting_keyword}"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
             next if node.else? && guard.nil?
 
-            autocorrect(corrector, node, condition, replacement || example, guard)
+            autocorrect(corrector, node, example, replacement, guard)
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
-
-          if_branch = node.if_branch
-          else_branch = node.else_branch
-
+        # rubocop:disable-next Metrics/AbcSize
+        def autocorrect(corrector, node, example, multiline_replacement, guard)
+          range = node.loc.keyword.join(node.condition.source_range)
+          corrector.replace(range, multiline_replacement || example)
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
-          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
-          else
-            corrector.remove(node.loc.end)
-            return unless node.else?
+          branches = [node.if_branch, node.else_branch]
+          guard_branch, leave_branch = guard == :else ? branches.reverse : branches
+
+          heredoc = find_heredoc_argument(guard_branch)
+          close_multiline_guard_clause(corrector, range, heredoc, guard) if multiline_replacement
 
-            corrector.remove(node.loc.else)
-            corrector.remove(range_of_branch_to_remove(node, guard))
+          if heredoc
+            return autocorrect_heredoc_argument(corrector, node, heredoc, leave_branch, guard)
           end
+
+          corrector.remove(node.loc.end)
+          return unless node.else?
+
+          corrector.remove(node.loc.else)
+          corrector.remove(range_of_branch_to_remove(node, guard))
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def heredoc?(argument)
           argument.respond_to?(:heredoc?) && argument.heredoc?
         end
 
-        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+        def find_heredoc_argument(node)
+          return unless node
+
+          node = node.children.first while node.begin_type?
+          return node if heredoc?(node)
+          return unless node.call_type?
+
+          node.arguments.reverse_each do |argument|
+            heredoc_argument = find_heredoc_argument(argument)
+            return heredoc_argument if heredoc_argument
+          end
+
+          find_heredoc_argument(node.receiver)
+        end
+
+        def close_multiline_guard_clause(corrector, range, heredoc, guard)
+          corrector.insert_after(guard && heredoc ? heredoc.loc.heredoc_end : range, "\nend")
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
-          remove_whole_lines(corrector, leave_branch.source_range)
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
+          end
+
           remove_whole_lines(corrector, node.loc.else)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
-          corrector.insert_after(
-            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
-          )
         end
 
         def range_of_branch_to_remove(node, guard)
@@ -274,7 +283,15 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment? || endless_method_body?(node)
+        end
+
+        # The body of an endless method is a single expression, so there is no
+        # room for a guard clause followed by the rest of the code.
+        def endless_method_body?(node)
+          parent = node.parent
+          parent&.any_def_type? && parent.endless?
         end
 
         def trivial?(node)

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

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
-      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
-      # EnforcedStyle.
+      # NOTE: This cop will ignore arrays where multiple items are all hashes,
+      # regardless of `EnforcedStyle`.
+      #
+      # [source,ruby]
+      # ----
+      # [{ one: 1 }, { two: 2 }]
+      # ----
       #
       # @example EnforcedStyle: braces (default)
       #   # bad
@@ -16,8 +21,11 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # bad
+      #   [one: 1, two: 2]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [{ one: 1, two: 2 }]
       #
       # @example EnforcedStyle: no_braces
       #   # bad
@@ -26,17 +34,24 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # bad
+      #   [{ one: 1, two: 2 }]
+      #
       #   # good
-      #   [{ one: 1 }, { two: 2 }]
+      #   [one: 1, two: 2]
       class HashAsLastArrayItem < Base
         include RangeHelp
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArrayLiteral]
+        end
+
         def on_hash(node)
           return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
-          return unless last_array_item?(array, node) && explicit_array?(array)
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -52,10 +67,12 @@ module RuboCop
           parent if parent&.array_type?
         end
 
-        def last_array_item?(array, node)
-          return false if array.child_nodes.all?(&:hash_type?)
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
 
-          array.children.last.equal?(node)
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
         end
 
         def explicit_array?(array)
@@ -67,7 +84,12 @@ module RuboCop
           return if node.braces?
 
           add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
-            corrector.wrap(node, '{', '}')
+            if node.single_line? || same_line?(node, node.parent)
+              corrector.wrap(node, '{', '}')
+            else
+              indent = indent(node)
+              corrector.wrap(node, "{\n#{indent}", "\n#{indent}}")
+            end
           end
         end
 

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

@@ -53,6 +53,12 @@ module RuboCop
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
+        # A hash literal as the first argument needs the parentheses of the call,
+        # which `Style/MethodCallWithArgsParentheses` removes in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
@@ -73,7 +79,7 @@ module RuboCop
           first_argument = node.first_argument
           if first_argument.hash_type?
             register_offense_for_hash(node, first_argument)
-          elsif first_argument.splat_type?
+          elsif first_argument.type?(:splat, :forwarded_restarg)
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
           elsif use_zip_method_without_argument?(first_argument)
             register_offense_for_zip_method(node, first_argument)
@@ -95,12 +101,30 @@ module RuboCop
         def register_offense_for_hash(node, hash_argument)
           add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
             corrector.replace(node, "{#{hash_argument.source}}")
-
-            parent = node.parent
-            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 
+        # Without parentheses, a hash literal at the start of the first argument would be
+        # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`.
+        def add_parentheses_to_parent_call(node, corrector)
+          node = node.parent while starts_parent?(node)
+          parent = node.parent
+          return unless parent&.type?(:call, :super, :yield)
+          return if parent.parenthesized? || operator_syntax?(parent)
+
+          add_parentheses(parent, corrector)
+        end
+
+        def starts_parent?(node)
+          node.parent && node.parent.source_range.begin_pos == node.source_range.begin_pos
+        end
+
+        # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is.
+        def operator_syntax?(call)
+          call.setter_method? || (call.operator_method? && !call.loc?(:dot))
+        end
+
         def register_offense_for_zip_method(node, zip_method)
           add_offense(node, message: MSG_TO_H) do |corrector|
             if zip_method.parenthesized?
@@ -121,17 +145,21 @@ module RuboCop
         end
 
         def multi_argument(node)
+          # A splat argument can expand to any number of elements, so the pairs
+          # can't be built statically and there is no literal hash to suggest.
+          return if node.arguments.any?(&:splat_type?)
+
           if node.arguments.count.odd?
             add_offense(node, message: MSG_LITERAL_MULTI_ARG)
           else
-            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
-              corrector.replace(node, args_to_hash(node.arguments))
+            correct_multi_argument(node)
+          end
+        end
 
-              parent = node.parent
-              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-                add_parentheses(parent, corrector)
-              end
-            end
+        def correct_multi_argument(node)
+          add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+            corrector.replace(node, args_to_hash(node.arguments))
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 

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

@@ -76,7 +76,7 @@ module RuboCop
         alias on_numblock on_block
         alias on_itblock on_block
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def check_unused_block_args(node, key, value)
           return if node.body.nil?
 
@@ -96,7 +96,6 @@ module RuboCop
             register_each_args_offense(node, message, 'each_value', unused_range)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def on_block_pass(node)
           kv_each_with_block_pass(node.parent) do |target, method|

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.
+      #
+      # This cop can be configured to prefer either bracket-style (`[]`)
+      # or fetch-style lookup. It is disabled by default.
+      #
+      # When enforcing `fetch` style, only single-argument bracket access is flagged.
+      # When enforcing `brackets` style, only `fetch` calls with a single key
+      # argument are flagged (not those with default values or blocks).
+      #
+      # @safety
+      #   This cop is unsafe because `Hash#[]` and `Hash#fetch` have different
+      #   semantics. `Hash#[]` returns `nil` for missing keys, while `Hash#fetch`
+      #   raises a `KeyError`. Replacing one with the other can change program
+      #   behavior in cases where the key is missing.
+      #
+      #   Additionally, it cannot be guaranteed that the receiver is a `Hash`
+      #   or responds to the replacement method.
+      #
+      # @example EnforcedStyle: brackets (default)
+      #   # bad
+      #   hash.fetch(key)
+      #
+      #   # good
+      #   hash[key]
+      #
+      #   # good - fetch with default value is allowed
+      #   hash.fetch(key, default)
+      #
+      #   # good - fetch with block is allowed
+      #   hash.fetch(key) { default }
+      #
+      #   # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled
+      #   ENV.fetch(key)
+      #
+      # @example EnforcedStyle: fetch
+      #   # bad
+      #   hash[key]
+      #
+      #   # good
+      #   hash.fetch(key)
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class HashLookupMethod < Base
+        include ConfigurableEnforcedStyle
+        include AllowedReceivers
+        extend AutoCorrector
+
+        BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
+        FETCH_MSG = 'Use `Hash#fetch` instead of `Hash#[]`.'
+
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, '(const {nil? cbase} :ENV)'
+
+        def on_send(node)
+          return if (receiver = node.receiver) && allowed_receiver?(receiver)
+          return if part_of_ignored_node?(node)
+
+          if offense_for_brackets?(node)
+            ignore_node(node.first_argument)
+            add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
+              correct_fetch_to_brackets(corrector, node)
+            end
+          elsif offense_for_fetch?(node)
+            ignore_node(node.first_argument)
+            add_offense(node, message: FETCH_MSG) do |corrector|
+              correct_brackets_to_fetch(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense_for_brackets?(node)
+          return false if style != :brackets || !node.receiver
+          return false if !node.method?(:fetch) || !node.arguments.one?
+          return false if node.block_literal? || node.csend_type?
+
+          !exempt_from_brackets?(node)
+        end
+
+        def exempt_from_brackets?(node)
+          comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
+        end
+
+        def comment_before_dot?(node)
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def env_fetch_preferred?(receiver)
+          env_const?(receiver) && processed_source.registry.enabled?(Style::FetchEnvVar, config)
+        end
+
+        def offense_for_fetch?(node)
+          style == :fetch && node.method?(:[]) && node.arguments.one? &&
+            !compound_assignment_target?(node)
+        end
+
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
+        end
+
+        def correct_fetch_to_brackets(corrector, node)
+          key = node.first_argument.source
+
+          corrector.replace(node.receiver.source_range.end.join(node.source_range.end), "[#{key}]")
+        end
+
+        def correct_brackets_to_fetch(corrector, node)
+          key = node.first_argument.source
+          replacement = node.loc.dot ? "fetch(#{key})" : ".fetch(#{key})"
+
+          corrector.replace(node.loc.selector.join(node.source_range.end), replacement)
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,22 @@ module RuboCop
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is a `Hash` or responds to the replacement method.
       #
+      #   Additionally, the replacement may change the order of the resulting
+      #   hash: `Hash#slice` returns entries in the order the keys are given,
+      #   whereas `select`, `filter`, and `reject` preserve the entry order of
+      #   the receiver.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   hash = {foo: 1, bar: 2, baz: 3}
+      #   keys = %i[baz foo]
+      #
+      #   hash.select { |k, _v| keys.include?(k) } # => {foo: 1, baz: 3}
+      #   hash.slice(*keys)                        # => {baz: 3, foo: 1}
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -142,6 +142,13 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
         NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
+        # Omitting the last hash value of a call without parentheses adds the parentheses,
+        # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses`
+        # would add again in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::SuperWithArgsParentheses]
+        end
+
         def on_hash(node)
           pairs = node.pairs
 
@@ -217,7 +224,7 @@ module RuboCop
           acceptable_19_syntax_symbol?(pair.key.source)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.delete_prefix!(':')
 
@@ -237,11 +244,12 @@ module RuboCop
           (sym_name.start_with?("'") && sym_name.end_with?("'")) ||
             (sym_name.start_with?('"') && sym_name.end_with?('"'))
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
+              next if pair.value_omission? && keyword_value?(pair)
+
               location = pair.source_range.begin.join(pair.loc.operator)
               add_offense(location, message: msg) do |corrector|
                 autocorrect(corrector, pair)
@@ -263,6 +271,8 @@ module RuboCop
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
+          # This runs once per pair, but the hash must only be wrapped once.
+          return unless pair_node.equal?(hash_node.pairs.first)
 
           corrector.wrap(hash_node, '{', '}')
         end
@@ -282,12 +292,16 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          op = pair_node.loc.operator
-
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(operator_range(pair_node))
+        end
+
+        def operator_range(pair_node)
+          op = pair_node.loc.operator
+
+          range_with_surrounding_space(op, newlines: !pair_node.value_omission?)
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -11,9 +11,11 @@ module RuboCop
       # (`transform_keys` was added in Ruby 2.5.)
       #
       # @safety
-      #   This cop is unsafe, as it can produce false positives if we are
-      #   transforming an enumerable of key-value-like pairs that isn't actually
-      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -21,10 +23,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
       #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      #   foo.merge(bar).map { |k, v| [k.to_s, v] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      #   foo.to_h.transform_keys { |k| k.to_sym }
+      #   foo.merge(bar).transform_keys { |k| k.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+      #   baz.map { |k, v| [k.to_s, v] }.to_h
       class HashTransformKeys < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -50,7 +60,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -61,7 +71,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -72,7 +82,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))