rubocop 1.52.1 → 1.79.2

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

@@ -17,9 +17,14 @@ module RuboCop
       # `foo&.bar` can start returning `nil` as well as what the method
       # returns.
       #
-      # The default for `MaxChainLength` is `2`
+      # The default for `MaxChainLength` is `2`.
       # We have limited the cop to not register an offense for method chains
-      # that exceed this option is set.
+      # that exceed this option's value.
+      #
+      # NOTE: This cop will recognize offenses but not autocorrect code when the
+      # right hand side (RHS) of the `&&` statement is an `||` statement
+      # (eg. `foo && (foo.bar? || foo.baz?)`). It can be corrected
+      # manually by removing the `foo &&` and adding `&.` to each `foo` on the RHS.
       #
       # @safety
       #   Autocorrection is unsafe because if a value is `false`, the resulting
@@ -81,7 +86,11 @@ module RuboCop
       #   foo.baz = bar if foo
       #   foo.baz + bar if foo
       #   foo.bar > 2 if foo
-      class SafeNavigation < Base
+      #
+      #   foo ? foo[index] : nil    # Ignored `foo&.[](index)` due to unclear readability benefit.
+      #   foo ? foo[idx] = v : nil  # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit.
+      #   foo ? foo * 42 : nil      # Ignored `foo&.*(42)` due to unclear readability benefit.
+      class SafeNavigation < Base # rubocop:disable Metrics/ClassLength
         include NilMethods
         include RangeHelp
         extend AutoCorrector
@@ -121,56 +130,142 @@ module RuboCop
           }
         PATTERN
 
+        # @!method and_with_rhs_or?(node)
+        def_node_matcher :and_with_rhs_or?, '(and _ {or (begin or)})'
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
+        # @!method and_inside_begin?(node)
+        def_node_matcher :and_inside_begin?, '`(begin and ...)'
+
+        # @!method strip_begin(node)
+        def_node_matcher :strip_begin, '{ (begin $!begin) $!(begin) }'
+
         def on_if(node)
           return if allowed_if_condition?(node)
 
-          check_node(node)
+          checked_variable, receiver, method_chain, _method = extract_parts_from_if(node)
+          return unless offending_node?(node, checked_variable, method_chain, receiver)
+
+          body = extract_if_body(node)
+          method_call = receiver.parent
+          return if dotless_operator_call?(method_call) || method_call.double_colon?
+
+          removal_ranges = [begin_range(node, body), end_range(node, body)]
+
+          report_offense(node, method_chain, method_call, *removal_ranges) do |corrector|
+            corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
+          end
         end
 
-        def on_and(node)
-          check_node(node)
+        def on_and(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+          collect_and_clauses(node).each do |(lhs, lhs_operator_range), (rhs, _rhs_operator_range)|
+            lhs_not_nil_check = not_nil_check?(lhs)
+            lhs_receiver = lhs_not_nil_check || lhs
+            rhs_receiver = find_matching_receiver_invocation(strip_begin(rhs), lhs_receiver)
+
+            next if !cop_config['ConvertCodeThatCanStartToReturnNil'] && lhs_not_nil_check
+            next unless offending_node?(node, lhs_receiver, rhs, rhs_receiver)
+
+            # Since we are evaluating every clause in potentially a complex chain of `and` nodes,
+            # we need to ensure that there isn't an object check happening
+            lhs_method_chain = find_method_chain(lhs_receiver)
+            next unless lhs_method_chain == lhs_receiver || lhs_not_nil_check
+
+            report_offense(
+              node,
+              rhs, rhs_receiver,
+              range_with_surrounding_space(range: lhs.source_range, side: :right),
+              range_with_surrounding_space(range: lhs_operator_range, side: :right),
+              offense_range: range_between(lhs.source_range.begin_pos, rhs.source_range.end_pos)
+            ) do |corrector|
+              corrector.replace(rhs_receiver, lhs_receiver.source)
+            end
+            ignore_node(node)
+          end
         end
 
         private
 
-        def check_node(node)
-          checked_variable, receiver, method_chain, method = extract_parts(node)
-          return if receiver != checked_variable || receiver.nil?
-          return if use_var_only_in_unless_modifier?(node, checked_variable)
-          return if chain_length(method_chain, method) > max_chain_length
-          return if unsafe_method_used?(method_chain, method)
-          return if method_chain.method?(:empty?)
+        def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
+          add_offense(offense_range) do |corrector|
+            next if ignored_node?(node)
+
+            # If the RHS is an `or` we cannot safely autocorrect because in order to remove
+            # the non-nil check we need to add safe-navs to all clauses where the receiver is used
+            next if and_with_rhs_or?(node)
 
-          add_offense(node) { |corrector| autocorrect(corrector, node) }
+            removal_ranges.each { |range| corrector.remove(range) }
+            yield corrector if block_given?
+
+            handle_comments(corrector, node, rhs)
+
+            add_safe_nav_to_all_methods_in_chain(corrector, rhs_receiver, rhs)
+          end
         end
 
-        def use_var_only_in_unless_modifier?(node, variable)
-          node.if_type? && node.unless? && !method_called?(variable)
+        def find_method_chain(node)
+          return node unless node&.parent&.call_type?
+
+          find_method_chain(node.parent)
+        end
+
+        def collect_and_clauses(node)
+          # Collect the lhs, operator and rhs of all `and` nodes
+          # `and` nodes can be nested and can contain `begin` nodes
+          # This gives us a source-ordered list of clauses that is then used to look
+          # for matching receivers as well as operator locations for offense and corrections
+          node.each_descendant(:and)
+              .inject(and_parts(node)) { |nodes, and_node| concat_nodes(nodes, and_node) }
+              .sort_by { |a| a.is_a?(RuboCop::AST::Node) ? a.source_range.begin_pos : a.begin_pos }
+              .each_slice(2)
+              .each_cons(2)
+        end
+
+        def concat_nodes(nodes, and_node)
+          return nodes if and_node.each_ancestor(:block).any?
+
+          nodes.concat(and_parts(and_node))
+        end
+
+        def and_parts(node)
+          parts = [node.loc.operator]
+          parts << node.rhs unless and_inside_begin?(node.rhs)
+          parts << node.lhs unless node.lhs.and_type? || and_inside_begin?(node.lhs)
+          parts
         end
 
-        def autocorrect(corrector, node)
-          body = extract_body(node)
-          method_call = method_call(node)
+        def offending_node?(node, lhs_receiver, rhs, rhs_receiver) # rubocop:disable Metrics/CyclomaticComplexity
+          return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
+          return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
+          return false if chain_length(rhs, rhs_receiver) > max_chain_length
+          return false if unsafe_method_used?(node, rhs, rhs_receiver.parent)
+          return false if rhs.send_type? && rhs.method?(:empty?)
 
-          corrector.remove(begin_range(node, body))
-          corrector.remove(end_range(node, body))
-          corrector.insert_before(method_call.loc.dot, '&') unless method_call.safe_navigation?
-          handle_comments(corrector, node, method_call)
+          true
+        end
 
-          add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
+        def use_var_only_in_unless_modifier?(node, variable)
+          node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        def extract_body(node)
-          if node.if_type? && node.ternary?
+        def extract_if_body(node)
+          if node.ternary?
             node.branches.find { |branch| !branch.nil_type? }
           else
             node.node_parts[1]
           end
         end
 
+        def dotless_operator_call?(method_call)
+          method_call = method_call.parent while method_call.parent.send_type?
+
+          return false if method_call.loc.dot
+
+          method_call.method?(:[]) || method_call.method?(:[]=) || method_call.operator_method?
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -201,20 +296,6 @@ module RuboCop
           node.else? || node.elsif?
         end
 
-        def method_call(node)
-          _checked_variable, matching_receiver, = extract_parts(node)
-          matching_receiver.parent
-        end
-
-        def extract_parts(node)
-          case node.type
-          when :if
-            extract_parts_from_if(node)
-          when :and
-            extract_parts_from_and(node)
-          end
-        end
-
         def extract_parts_from_if(node)
           variable, receiver =
             if node.ternary?
@@ -230,16 +311,6 @@ module RuboCop
           [checked_variable, matching_receiver, receiver, method]
         end
 
-        def extract_parts_from_and(node)
-          checked_variable, rhs = *node
-          if cop_config['ConvertCodeThatCanStartToReturnNil']
-            checked_variable = not_nil_check?(checked_variable) || checked_variable
-          end
-
-          checked_variable, matching_receiver, method = extract_common_parts(rhs, checked_variable)
-          [checked_variable, matching_receiver, rhs, method]
-        end
-
         def extract_common_parts(method_chain, checked_variable)
           matching_receiver = find_matching_receiver_invocation(method_chain, checked_variable)
 
@@ -249,38 +320,51 @@ module RuboCop
         end
 
         def find_matching_receiver_invocation(method_chain, checked_variable)
-          return nil unless method_chain
+          return nil unless method_chain.respond_to?(:receiver)
 
           receiver = method_chain.receiver
 
-          return receiver if receiver == checked_variable
+          return receiver if matching_nodes?(receiver, checked_variable)
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def matching_nodes?(left, right)
+          left == right || matching_call_nodes?(left, right)
+        end
+
+        def matching_call_nodes?(left, right)
+          return false unless left && right.respond_to?(:call_type?)
+
+          left.call_type? && right.call_type? && left.children == right.children
+        end
+
         def chain_length(method_chain, method)
-          method.each_ancestor(:send).inject(1) do |total, ancestor|
+          method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain
 
             total + 1
           end
         end
 
-        def unsafe_method_used?(method_chain, method)
-          return true if unsafe_method?(method)
+        def unsafe_method_used?(node, method_chain, method)
+          return true if unsafe_method?(node, method)
 
           method.each_ancestor(:send).any? do |ancestor|
-            break true unless config.for_cop('Lint/SafeNavigationChain')['Enabled']
+            break true unless config.cop_enabled?('Lint/SafeNavigationChain')
 
-            break true if unsafe_method?(ancestor)
+            break true if unsafe_method?(node, ancestor)
             break true if nil_methods.include?(ancestor.method_name)
             break false if ancestor == method_chain
           end
         end
 
-        def unsafe_method?(send_node)
-          negated?(send_node) ||
-            send_node.assignment? ||
+        def unsafe_method?(node, send_node)
+          return true if negated?(send_node)
+
+          return false if node.respond_to?(:ternary?) && node.ternary?
+
+          send_node.assignment? ||
             (!send_node.dot? && !send_node.safe_navigation?)
         end
 
@@ -309,7 +393,7 @@ module RuboCop
                                                  method_chain)
           start_method.each_ancestor do |ancestor|
             break unless %i[send block].include?(ancestor.type)
-            next unless ancestor.send_type?
+            next if !ancestor.send_type? || ancestor.operator_method?
 
             corrector.insert_before(ancestor.loc.dot, '&')
 

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces safe navigation chains length to not exceed the configured maximum.
+      # The longer the chain is, the harder it becomes to track what on it could be
+      # returning `nil`.
+      #
+      # There is a potential interplay with `Style/SafeNavigation` - if both are enabled
+      # and their settings are "incompatible", one of the cops will complain about what
+      # the other proposes.
+      #
+      # E.g. if `Style/SafeNavigation` is configured with `MaxChainLength: 2` (default)
+      # and this cop is configured with `Max: 1`, then for `foo.bar.baz if foo` the former
+      # will suggest `foo&.bar&.baz`, which is an offense for the latter.
+      #
+      # @example Max: 2 (default)
+      #   # bad
+      #   user&.address&.zip&.upcase
+      #
+      #   # good
+      #   user&.address&.zip
+      #   user.address.zip if user
+      #
+      class SafeNavigationChainLength < Base
+        MSG = 'Avoid safe navigation chains longer than %<max>d calls.'
+
+        def on_csend(node)
+          safe_navigation_chains = safe_navigation_chains(node)
+          return if safe_navigation_chains.size < max
+
+          add_offense(safe_navigation_chains.last, message: format(MSG, max: max))
+        end
+
+        private
+
+        def safe_navigation_chains(node)
+          node.each_ancestor.with_object([]) do |parent, chains|
+            break chains unless parent.csend_type?
+
+            chains << parent
+          end
+        end
+
+        def max
+          cop_config['Max'] || 2
+        end
+      end
+    end
+  end
+end

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

@@ -35,7 +35,7 @@ module RuboCop
 
         # @!method sample_candidate?(node)
         def_node_matcher :sample_candidate?, <<~PATTERN
-          (send $(send _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
+          (call $(call _ :shuffle $...) ${:#{RESTRICT_ON_SEND.join(' :')}} $...)
         PATTERN
 
         def on_send(node)
@@ -52,6 +52,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -109,9 +110,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def source_range(shuffle_node, node)
-          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
-                                    shuffle_node.loc.selector.begin_pos,
-                                    node.source_range.end_pos)
+          shuffle_node.loc.selector.join(node.source_range.end)
         end
 
         def message(shuffle_arg, method, method_args, range)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for places where an subset of an Enumerable (array,
+      # Looks for places where a 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.
       #
@@ -27,7 +27,7 @@ module RuboCop
       #   so the correction may not be actually equivalent.
       #
       # @example
-      #   # bad (select or find_all)
+      #   # bad (select, filter, or find_all)
       #   array.select { |x| x.match? /regexp/ }
       #   array.select { |x| /regexp/.match?(x) }
       #   array.select { |x| x =~ /regexp/ }
@@ -47,16 +47,19 @@ module RuboCop
         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
-        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        RESTRICT_ON_SEND = %i[select filter find_all reject].freeze
+        REPLACEMENTS = { select: 'grep', filter: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
+        OPPOSITE_REPLACEMENTS = {
+          select: 'grep_v', filter: 'grep_v', find_all: 'grep_v', reject: 'grep'
+        }.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})
+            (block call (args (arg $_)) ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (numblock call $1 ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
+            (itblock call $_ ${(send _ %REGEXP_METHODS _) match-with-lvasgn})
           }
         PATTERN
 
@@ -64,9 +67,9 @@ module RuboCop
         # @!method creates_hash?(node)
         def_node_matcher :creates_hash?, <<~PATTERN
           {
-            (send (const _ :Hash) {:new :[]} ...)
-            (block (send (const _ :Hash) :new ...) ...)
-            (send _ { :to_h :to_hash } ...)
+            (call (const _ :Hash) {:new :[]} ...)
+            (block (call (const _ :Hash) :new ...) ...)
+            (call _ { :to_h :to_hash } ...)
           }
         PATTERN
 
@@ -84,8 +87,9 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
+          return if target_ruby_version < 2.6 && node.method?(:filter)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
           return if receiver_allowed?(block_node.receiver)
@@ -99,7 +103,8 @@ module RuboCop
 
           register_offense(node, block_node, regexp, replacement)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        alias on_csend on_send
 
         private
 
@@ -133,6 +138,7 @@ module RuboCop
           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
@@ -146,7 +152,8 @@ module RuboCop
           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)
+             (block.type?(:numblock, :itblock) ||
+              node.receiver.source == block.first_argument.source)
             node.first_argument
           elsif node.first_argument.lvar_type?
             node.receiver

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

@@ -16,7 +16,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use self-assignment shorthand `%<method>s=`.'
-        OPS = %i[+ - * ** / | &].freeze
+        OPS = %i[+ - * ** / % ^ << >> | &].freeze
 
         def self.autocorrect_incompatible_with
           [Layout::SpaceAroundOperators]
@@ -37,33 +37,29 @@ module RuboCop
         private
 
         def check(node, var_type)
-          var_name, rhs = *node
-          return unless rhs
+          return unless (rhs = node.expression)
 
-          if rhs.send_type?
-            check_send_node(node, rhs, var_name, var_type)
+          if rhs.send_type? && rhs.arguments.one?
+            check_send_node(node, rhs, node.name, var_type)
           elsif rhs.operator_keyword?
-            check_boolean_node(node, rhs, var_name, var_type)
+            check_boolean_node(node, rhs, node.name, var_type)
           end
         end
 
         def check_send_node(node, rhs, var_name, var_type)
-          receiver, method_name, *_args = *rhs
-          return unless OPS.include?(method_name)
+          return unless OPS.include?(rhs.method_name)
 
           target_node = s(var_type, var_name)
-          return unless receiver == target_node
+          return unless rhs.receiver == target_node
 
-          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+          add_offense(node, message: format(MSG, method: rhs.method_name)) do |corrector|
             autocorrect(corrector, node)
           end
         end
 
         def check_boolean_node(node, rhs, var_name, var_type)
-          first_operand, _second_operand = *rhs
-
           target_node = s(var_type, var_name)
-          return unless first_operand == target_node
+          return unless rhs.lhs == target_node
 
           operator = rhs.loc.operator.source
           add_offense(node, message: format(MSG, method: operator)) do |corrector|
@@ -72,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          _var_name, rhs = *node
+          rhs = node.expression
 
           if rhs.send_type?
             autocorrect_send_node(corrector, node, rhs)
@@ -82,13 +78,11 @@ module RuboCop
         end
 
         def autocorrect_send_node(corrector, node, rhs)
-          _receiver, method_name, args = *rhs
-          apply_autocorrect(corrector, node, rhs, method_name.to_s, args)
+          apply_autocorrect(corrector, node, rhs, rhs.method_name, rhs.first_argument)
         end
 
         def autocorrect_boolean_node(corrector, node, rhs)
-          _first_operand, second_operand = *rhs
-          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, second_operand)
+          apply_autocorrect(corrector, node, rhs, rhs.loc.operator.source, rhs.rhs)
         end
 
         def apply_autocorrect(corrector, node, rhs, operator, new_rhs)

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

@@ -62,9 +62,6 @@ module RuboCop
         private
 
         def check_for_line_terminator_or_opener
-          # Make the obvious check first
-          return unless processed_source.raw_source.include?(';')
-
           each_semicolon do |line, column, token_before_semicolon|
             register_semicolon(line, column, false, token_before_semicolon)
           end
@@ -83,6 +80,7 @@ module RuboCop
           processed_source.tokens.group_by(&:line)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def semicolon_position(tokens)
           if tokens.last.semicolon?
             -1
@@ -93,10 +91,13 @@ module RuboCop
           elsif exist_semicolon_after_left_curly_brace?(tokens) ||
                 exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_after_left_lambda_curly_brace?(tokens)
+            3
           elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
             -4
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def exist_semicolon_before_right_curly_brace?(tokens)
           tokens[-2]&.right_curly_brace? && tokens[-3]&.semicolon?
@@ -106,6 +107,10 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_after_left_lambda_curly_brace?(tokens)
+          tokens[2]&.type == :tLAMBEG && tokens[3]&.semicolon?
+        end
+
         def exist_semicolon_before_right_string_interpolation_brace?(tokens)
           tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
         end
@@ -136,7 +141,7 @@ module RuboCop
 
         def expressions_per_line(exprs)
           # create a map matching lines to the number of expressions on them
-          exprs_lines = exprs.map(&:first_line)
+          exprs_lines = exprs.map(&:last_line)
           exprs_lines.group_by(&:itself)
         end
 
@@ -159,7 +164,7 @@ module RuboCop
 
           ast = processed_source.ast
           @range_nodes = ast.range_type? ? [ast] : []
-          @range_nodes.concat(ast.each_descendant(:irange, :erange).to_a)
+          @range_nodes.concat(ast.each_descendant(:range).to_a)
         end
       end
     end

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

@@ -7,12 +7,12 @@ module RuboCop
       #
       # @example
       #   # bad
-      #   Foo.send(:bar)
-      #   quuz.send(:fred)
+      #   Foo.send(bar)
+      #   quuz.send(fred)
       #
       #   # good
-      #   Foo.__send__(:bar)
-      #   quuz.public_send(:fred)
+      #   Foo.__send__(bar)
+      #   quuz.public_send(fred)
       class Send < Base
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
         RESTRICT_ON_SEND = %i[send].freeze