rubocop 1.19.0 → 1.23.0

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

@@ -120,11 +120,10 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.basic_conditional? &&
-            node.modifier_form? ||
+          (node.basic_conditional? && node.modifier_form?) ||
             node.range_type? ||
             node.rescue_type? ||
-            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
         def without_argument_parentheses_method?(node)

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

@@ -9,6 +9,10 @@ module RuboCop
       # In such cases `fetch(key, value)` method is faster
       # than `fetch(key) { value }`.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   does not have a different implementation of `fetch`.
+      #
       # @example SafeForConstants: false (default)
       #   # bad
       #   hash.fetch(:key) { 5 }

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

@@ -25,6 +25,7 @@ module RuboCop
       #   require_relative '../foo.so'
       #
       class RedundantFileExtensionInRequire < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
@@ -39,13 +40,21 @@ module RuboCop
           require_call?(node) do |name_node|
             return unless name_node.value.end_with?('.rb')
 
-            add_offense(name_node) do |corrector|
-              correction = name_node.value.delete_suffix('.rb')
+            extension_range = extension_range(name_node)
 
-              corrector.replace(name_node, "'#{correction}'")
+            add_offense(extension_range) do |corrector|
+              corrector.remove(extension_range)
             end
           end
         end
+
+        private
+
+        def extension_range(name_node)
+          end_of_path_string = name_node.source_range.end_pos
+
+          range_between(end_of_path_string - 4, end_of_path_string - 1)
+        end
       end
     end
   end

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

@@ -7,6 +7,9 @@ module RuboCop
       #
       # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
+      # NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
+      # string literals when `# frozen-string-literal: true` is used.
+      #
       # @example
       #   # bad
       #   CONST = 1.freeze
@@ -37,9 +40,7 @@ module RuboCop
           node = strip_parenthesis(node)
 
           return true if node.immutable_literal?
-
-          return true if FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-                         frozen_string_literals_enabled?
+          return true if frozen_string_literal?(node)
 
           target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
         end
@@ -58,7 +59,6 @@ module RuboCop
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
-            (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -56,7 +56,7 @@ module RuboCop
           first_child = node.children.first
 
           variable_interpolation?(first_child) ||
-            first_child.send_type? && !first_child.operator_method?
+            (first_child.send_type? && !first_child.operator_method?)
         end
 
         def interpolation?(node)

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

@@ -65,9 +65,8 @@ module RuboCop
         end
 
         def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
         end
 
         def message(node)

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

@@ -100,6 +100,10 @@ module RuboCop
           add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
+        def on_in_pattern(node)
+          add_match_var_scopes(node)
+        end
+
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
@@ -185,6 +189,12 @@ module RuboCop
             add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
           end
         end
+
+        def add_match_var_scopes(in_pattern_node)
+          in_pattern_node.each_descendant(:match_var) do |match_var_node|
+            @local_variables_scopes[in_pattern_node] << match_var_node.children.first
+          end
+        end
       end
     end
   end

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

@@ -6,9 +6,10 @@ module RuboCop
       # This cop checks for places where redundant assignments are made for in place
       # modification methods.
       #
-      # This cop is marked as unsafe, because it can produce false positives for
-      # user defined methods having one of the expected names, but not modifying
-      # its receiver in place.
+      # @safety
+      #   This cop is unsafe, because it can produce false positives for
+      #   user defined methods having one of the expected names, but not modifying
+      #   its receiver in place.
       #
       # @example
       #   # bad

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for places where conditional branch makes redundant self-assignment.
       #
+      # It only detects local variable because it may replace state of instance variable,
+      # class variable, and global variable that have state across methods with `nil`.
+      #
       # @example
       #
       #   # bad
@@ -32,11 +35,11 @@ module RuboCop
 
         def on_lvasgn(node)
           variable, expression = *node
-          return unless expression&.if_type?
-          return unless expression.ternary? || expression.else?
+          return unless use_if_and_else_branch?(expression)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
+          return if inconvertible_to_modifier?(if_branch, else_branch)
 
           if self_assign?(variable, if_branch)
             register_offense(expression, if_branch, else_branch, 'unless')
@@ -45,41 +48,33 @@ module RuboCop
           end
         end
 
-        alias on_ivasgn on_lvasgn
-        alias on_cvasgn on_lvasgn
-        alias on_gvasgn on_lvasgn
-
         private
 
-        def self_assign?(variable, branch)
-          variable.to_s == branch&.source
+        def use_if_and_else_branch?(expression)
+          return false unless expression&.if_type?
+
+          !expression.ternary? || !expression.else?
         end
 
-        def register_offense(if_node, offense_branch, opposite_branch, keyword)
-          add_offense(offense_branch) do |corrector|
-            if if_node.ternary?
-              replacement = "#{opposite_branch.source} #{keyword} #{if_node.condition.source}"
-              corrector.replace(if_node, replacement)
-            else
-              if_node_loc = if_node.loc
+        def inconvertible_to_modifier?(if_branch, else_branch)
+          multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
+        end
 
-              range = range_by_whole_lines(offense_branch.source_range, include_final_newline: true)
-              corrector.remove(range)
-              range = range_by_whole_lines(if_node_loc.else, include_final_newline: true)
-              corrector.remove(range)
+        def multiple_statements?(branch)
+          branch && branch.children.compact.count > 1
+        end
 
-              autocorrect_if_condition(corrector, if_node, if_node_loc, keyword)
-            end
-          end
+        def self_assign?(variable, branch)
+          variable.to_s == branch&.source
         end
 
-        def autocorrect_if_condition(corrector, if_node, if_node_loc, keyword)
-          else_branch = if_node.else_branch
+        def register_offense(if_node, offense_branch, opposite_branch, keyword)
+          add_offense(offense_branch) do |corrector|
+            assignment_value = opposite_branch ? opposite_branch.source : 'nil'
+            replacement = "#{assignment_value} #{keyword} #{if_node.condition.source}"
 
-          if else_branch.respond_to?(:elsif?) && else_branch.elsif?
-            corrector.replace(if_node.condition, else_branch.condition.source)
-          else
-            corrector.replace(if_node_loc.keyword, keyword)
+            corrector.replace(if_node, replacement)
           end
         end
       end

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

@@ -12,6 +12,33 @@ module RuboCop
       # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
       # after which only the first or last element is used.
       #
+      # @safety
+      #   This cop is unsafe, because `sort...last` and `max` may not return the
+      #   same element in all cases.
+      #
+      #   In an enumerable where there are multiple elements where `a <=> b == 0`,
+      #   or where the transformation done by the `sort_by` block has the
+      #   same result, `sort.last` and `max` (or `sort_by.last` and `max_by`)
+      #   will return different elements. `sort.last` will return the last
+      #   element but `max` will return the first element.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #     class MyString < String; end
+      #     strings = [MyString.new('test'), 'test']
+      #     strings.sort.last.class   #=> String
+      #     strings.max.class         #=> MyString
+      #   ----
+      #
+      #   [source,ruby]
+      #   ----
+      #     words = %w(dog horse mouse)
+      #     words.sort_by { |word| word.length }.last   #=> 'mouse'
+      #     words.max_by { |word| word.length }         #=> 'horse'
+      #   ----
+      #
       # @example
       #   # bad
       #   [2, 1, 3].sort.first
@@ -75,33 +102,39 @@ module RuboCop
         MATCHER
 
         def on_send(node)
-          if (sort_node, sorter, accessor = redundant_sort?(node.parent))
-            ancestor = node.parent
-          elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
-            ancestor = node.parent.parent
-          else
-            return
-          end
+          ancestor, sort_node, sorter, accessor =
+            find_redundant_sort(node.parent, node.parent&.parent)
+          return unless ancestor
 
-          message = message(ancestor, sorter, accessor)
+          register_offense(ancestor, sort_node, sorter, accessor)
+        end
+
+        private
 
-          add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
-            autocorrect(corrector, ancestor, sort_node, sorter, accessor)
+        def find_redundant_sort(*nodes)
+          nodes.each do |node|
+            if (sort_node, sorter, accessor = redundant_sort?(node))
+              return [node, sort_node, sorter, accessor]
+            end
           end
+
+          nil
         end
 
-        private
+        def register_offense(node, sort_node, sorter, accessor)
+          message = message(node, sorter, accessor)
 
-        def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          add_offense(offense_range(sort_node, node), message: message) do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
 
-          # Replace "sort" or "sort_by" with the appropriate min/max method.
-          corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
+          end
         end
 
-        def offense_range(sort_node, ancestor)
-          range_between(sort_node.loc.selector.begin_pos, ancestor.loc.expression.end_pos)
+        def offense_range(sort_node, node)
+          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
 
         def message(node, sorter, accessor)

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

@@ -107,7 +107,7 @@ module RuboCop
         private
 
         def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) || allowed_mixed_slash?(node)
+          (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
         end
 
         def allowed_mixed_slash?(node)
@@ -115,13 +115,13 @@ module RuboCop
         end
 
         def allowed_percent_r_literal?(node)
-          style == :slashes && contains_disallowed_slash?(node) ||
+          (style == :slashes && contains_disallowed_slash?(node)) ||
             style == :percent_r ||
             allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? || contains_disallowed_slash?(node)
+          (style == :mixed && node.multiline?) || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)

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

@@ -74,7 +74,8 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :return && !return_nil_node?(node) || style == :return_nil && !return_node?(node)
+          (style == :return && !return_nil_node?(node)) ||
+            (style == :return_nil && !return_node?(node))
         end
 
         def scoped_node?(node)

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

@@ -10,14 +10,25 @@ module RuboCop
       # need to be changed to use safe navigation. We have limited the cop to
       # not register an offense for method chains that exceed 2 methods.
       #
-      # Configuration option: ConvertCodeThatCanStartToReturnNil
-      # The default for this is `false`. When configured to `true`, this will
+      # The default for `ConvertCodeThatCanStartToReturnNil` is `false`.
+      # When configured to `true`, this will
       # check for code in the format `!foo.nil? && foo.bar`. As it is written,
       # the return of this code is limited to `false` and whatever the return
       # of the method is. If this is converted to safe navigation,
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
+      # @safety
+      #   Autocorrection is unsafe because if a value is `false`, the resulting
+      #   code will have different behaviour or raise an error.
+      #
+      #   [source,ruby]
+      #   ----
+      #   x = false
+      #   x && x.foo  # return false
+      #   x&.foo      # raises NoMethodError
+      #   ----
+      #
       # @example
       #   # bad
       #   foo.bar if foo

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for places where an subset of an Enumerable (array,
+      # range, set, etc.; see note below) is calculated based on a `Regexp`
+      # match, and suggests `grep` or `grep_v` instead.
+      #
+      # NOTE: Hashes do not behave as you may expect with `grep`, which
+      # means that `hash.grep` is not equivalent to `hash.select`. Although
+      # RuboCop is limited by static analysis, this cop attempts to avoid
+      # registering an offense when the receiver is a hash (hash literal,
+      # `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`).
+      #
+      # NOTE: `grep` and `grep_v` were optimized when used without a block
+      # in Ruby 3.0, but may be slower in previous versions.
+      # See https://bugs.ruby-lang.org/issues/17030
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because `MatchData` will
+      #   not be created by `grep`, but may have previously been relied
+      #   upon after the `match?` or `=~` call.
+      #
+      #   Additionally, the cop cannot guarantee that the receiver of
+      #   `select` or `reject` is actually an array by static analysis,
+      #   so the correction may not be actually equivalent.
+      #
+      # @example
+      #   # bad (select or find_all)
+      #   array.select { |x| x.match? /regexp/ }
+      #   array.select { |x| /regexp/.match?(x) }
+      #   array.select { |x| x =~ /regexp/ }
+      #   array.select { |x| /regexp/ =~ x }
+      #
+      #   # bad (reject)
+      #   array.reject { |x| x.match? /regexp/ }
+      #   array.reject { |x| /regexp/.match?(x) }
+      #   array.reject { |x| x =~ /regexp/ }
+      #   array.reject { |x| /regexp/ =~ x }
+      #
+      #   # good
+      #   array.grep(regexp)
+      #   array.grep_v(regexp)
+      class SelectByRegexp < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
+        RESTRICT_ON_SEND = %i[select find_all reject].freeze
+        REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
+        REGEXP_METHODS = %i[match? =~].to_set.freeze
+
+        # @!method regexp_match?(node)
+        def_node_matcher :regexp_match?, <<~PATTERN
+          {
+            (block send (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock send $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+          }
+        PATTERN
+
+        # Returns true if a node appears to return a hash
+        # @!method creates_hash?(node)
+        def_node_matcher :creates_hash?, <<~PATTERN
+          {
+            (send (const _ :Hash) {:new :[]} ...)
+            (block (send (const _ :Hash) :new ...) ...)
+            (send _ { :to_h :to_hash } ...)
+          }
+        PATTERN
+
+        # @!method calls_lvar?(node, name)
+        def_node_matcher :calls_lvar?, <<~PATTERN
+          {
+            (send (lvar %1) ...)
+            (send ... (lvar %1))
+            (match-with-lvasgn regexp (lvar %1))
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (block_node = node.block_node)
+          return if block_node.body.begin_type?
+          return if receiver_allowed?(block_node.receiver)
+          return unless (regexp_method_send_node = extract_send_node(block_node))
+          return if match_predicate_without_receiver?(regexp_method_send_node)
+
+          regexp = find_regexp(regexp_method_send_node, block_node)
+          register_offense(node, block_node, regexp)
+        end
+
+        private
+
+        def receiver_allowed?(node)
+          return false unless node
+
+          node.hash_type? || creates_hash?(node)
+        end
+
+        def register_offense(node, block_node, regexp)
+          replacement = REPLACEMENTS[node.method_name.to_sym]
+          message = format(MSG, replacement: replacement, original_method: node.method_name)
+
+          add_offense(block_node, message: message) do |corrector|
+            # Only correct if it can be determined what the regexp is
+            if regexp
+              range = range_between(node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+              corrector.replace(range, "#{replacement}(#{regexp.source})")
+            end
+          end
+        end
+
+        def extract_send_node(block_node)
+          return unless (block_arg_name, regexp_method_send_node = regexp_match?(block_node))
+
+          block_arg_name = :"_#{block_arg_name}" if block_node.numblock_type?
+          return unless calls_lvar?(regexp_method_send_node, block_arg_name)
+
+          regexp_method_send_node
+        end
+
+        def find_regexp(node, block)
+          return node.child_nodes.first if node.match_with_lvasgn_type?
+
+          if node.receiver.lvar_type? &&
+             (block.numblock_type? || node.receiver.source == block.arguments.first.source)
+            node.first_argument
+          elsif node.first_argument.lvar_type?
+            node.receiver
+          end
+        end
+
+        def match_predicate_without_receiver?(node)
+          node.send_type? && node.method?(:match?) && node.receiver.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,11 @@ module RuboCop
       # Sometimes using dig method ends up with just a single
       # argument. In such cases, dig should be replaced with [].
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is an `Enumerable` or does not have a nonstandard implementation
+      #   of `dig`.
+      #
       # @example
       #   # bad
       #   { key: 'value' }.dig(:key)

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

@@ -6,6 +6,19 @@ module RuboCop
       # This cop checks that arrays are sliced with endless ranges instead of
       # `ary[start..-1]` on Ruby 2.6+.
       #
+      # @safety
+      #   This cop is unsafe because `x..-1` and `x..` are only guaranteed to
+      #   be equivalent for `Array#[]`, and the cop cannot determine what class
+      #   the receiver is.
+      #
+      #   For example:
+      #   [source,ruby]
+      #   ----
+      #   sum = proc { |ary| ary.sum }
+      #   sum[-3..-1] # => -6
+      #   sum[-3..] # Hangs forever
+      #   ----
+      #
       # @example
       #   # bad
       #   items[1..-1]

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

@@ -38,6 +38,10 @@ module RuboCop
 
         MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
+        def self.autocorrect_incompatible_with
+          [Style::NegatedIf, Style::NegatedUnless]
+        end
+
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 

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

@@ -9,6 +9,10 @@ module RuboCop
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.
       #
+      # @safety
+      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
+      #   true, replacing perl-style variables with english variables will break.
+      #
       # @example EnforcedStyle: use_english_names (default)
       #   # good
       #   require 'English' # or this could be in another file.

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

@@ -7,9 +7,10 @@ module RuboCop
       # replaced with a module. Classes should be used only when it makes sense to create
       # instances out of them.
       #
-      # This cop is marked as unsafe, because it is possible that this class is a parent
-      # for some other subclass, monkey-patched with instance methods or
-      # a dummy instance is instantiated from it somewhere.
+      # @safety
+      #   This cop is unsafe, because it is possible that this class is a parent
+      #   for some other subclass, monkey-patched with instance methods or
+      #   a dummy instance is instantiated from it somewhere.
       #
       # @example
       #   # bad
@@ -60,8 +61,7 @@ module RuboCop
           return false if nodes.empty?
 
           nodes.all? do |node|
-            node_visibility(node) == :public &&
-              node.defs_type? ||
+            (node_visibility(node) == :public && node.defs_type?) ||
               sclass_convertible_to_module?(node) ||
               node.equals_asgn? ||
               extend_call?(node)

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

@@ -5,8 +5,10 @@ module RuboCop
     module Style
       # Checks for uses of `String#split` with empty string or regexp literal argument.
       #
-      # This cop is marked as unsafe. But probably it's quite unlikely that some other class would
-      # define a `split` method that takes exactly the same arguments.
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behaviour, it would be registered as a false positive.
       #
       # @example
       #   # bad

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

@@ -23,6 +23,10 @@ module RuboCop
       # This is useful when the receiver is some expression that returns string like `Pathname`
       # instead of a string literal.
       #
+      # @safety
+      #   This cop is unsafe in `aggressive` mode, as it cannot be guaranteed that
+      #   the receiver is actually a string, which can result in a false positive.
+      #
       # @example Mode: aggressive (default)
       #   # bad
       #   email_with_name = user.name + ' <' + user.email + '>'
@@ -93,7 +97,7 @@ module RuboCop
 
         def offensive_for_mode?(receiver_node)
           mode = cop_config['Mode'].to_sym
-          mode == :aggressive || mode == :conservative && receiver_node.str_type?
+          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
         end
 
         def line_end_concatenation?(node)

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
+      # @safety
+      #   This cop is unsafe because while symbols are preferred for hash keys,
+      #   there are instances when string keys are required.
+      #
       # @example
       #   # bad
       #   { 'one' => 1, 'two' => 2, 'three' => 3 }