rubocop 1.71.0 → 1.71.1

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

@@ -209,7 +209,7 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.sym_type? || pair.key.dsym_type?
+          return false unless pair.key.type?(:sym, :dsym)
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end

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

@@ -203,17 +203,36 @@ module RuboCop
               corrector.remove(range)
               next if inserted_expression
 
-              if insert_position == :after_condition
-                corrector.insert_after(node, "\n#{expression.source}")
+              if node.parent&.assignment?
+                correct_assignment(corrector, node, expression, insert_position)
               else
-                corrector.insert_before(node, "#{expression.source}\n")
+                correct_no_assignment(corrector, node, expression, insert_position)
               end
+
               inserted_expression = true
             end
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+        def correct_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
+            corrector.remove(assignment)
+            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+          else
+            corrector.insert_before(node.parent, "#{expression.source}\n")
+          end
+        end
+
+        def correct_no_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            corrector.insert_after(node, "\n#{expression.source}")
+          else
+            corrector.insert_before(node, "#{expression.source}\n")
+          end
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)
 

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

@@ -103,7 +103,7 @@ module RuboCop
 
         def defined_argument_is_undefined?(if_node, defined_node)
           defined_argument = defined_node.first_argument
-          return false unless defined_argument.lvar_type? || defined_argument.send_type?
+          return false unless defined_argument.type?(:lvar, :send)
 
           if_node.left_siblings.none? do |sibling|
             sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
@@ -112,11 +112,11 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.match_pattern_type? || condition.match_pattern_p_type?
+          if condition.type?(:match_pattern, :match_pattern_p)
             [condition]
           else
             condition.each_descendant.select do |node|
-              node.match_pattern_type? || node.match_pattern_p_type?
+              node.type?(:match_pattern, :match_pattern_p)
             end
           end
         end

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

@@ -67,7 +67,7 @@ module RuboCop
 
         # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
-          (if #return_boolean_value? {(true) (false) | (false) (true)})
+          (if #return_boolean_value? <true false>)
         PATTERN
         # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'

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

@@ -42,7 +42,7 @@ module RuboCop
         def message(node)
           template = if require_newline?(node)
                        MSG_NEWLINE
-                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
+                     elsif node.else_branch&.type?(:if, :begin) ||
                            use_masgn_or_block_in_branches?(node)
                        MSG_IF_ELSE
                      else
@@ -66,7 +66,7 @@ module RuboCop
 
         def use_masgn_or_block_in_branches?(node)
           node.branches.compact.any? do |branch|
-            branch.masgn_type? || branch.block_type? || branch.numblock_type?
+            branch.type?(:masgn, :any_block)
           end
         end
 

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.while_post_type? || node.until_post_type?
+          if node.type?(:while_post, :until_post)
             replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
             replace_source(corrector, node.source_range, modifier_replacement(node))

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

@@ -60,18 +60,18 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(call $(...) $_ $...) :!)
-            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (any_block $(call $(...) $_) $...) :!)
             (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(call (...) $_) ... { $(call ... :!)
-                                                   $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(call ... :!))
-                                                   (begin ... $(send (...) {:!= :!~} ...))
-                                                 })
+          (any_block $(call (...) $_) ... { $(call ... :!)
+                                            $(send (...) {:!= :!~} ...)
+                                            (begin ... $(call ... :!))
+                                            (begin ... $(send (...) {:!= :!~} ...))
+                                          })
         PATTERN
 
         def on_send(node)

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

@@ -26,7 +26,7 @@ module RuboCop
 
         def on_lvasgn(node)
           return unless node.name == :it
-          return unless node.each_ancestor(:block, :numblock).any?
+          return unless node.each_ancestor(:any_block).any?
 
           add_offense(node.loc.name)
         end

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

@@ -57,7 +57,7 @@ module RuboCop
 
         def append_newline_to_last_kwoptarg(arguments, corrector)
           last_argument = arguments.last
-          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+          return if last_argument.type?(:kwrestarg, :blockarg)
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
           corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?

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

@@ -72,7 +72,7 @@ module RuboCop
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
             ^({begin kwbegin block} ...)
-            ({block numblock} (send !{nil? self} :each) _
+            (any_block (send !{nil? self} :each) _
               (send (lvar _) {:<< :push :append} #suitable_argument_node?))
           ]
         PATTERN

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

@@ -40,7 +40,7 @@ module RuboCop
         # @!method map_to_h(node)
         def_node_matcher :map_to_h, <<~PATTERN
           {
-            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call (any_block $(call _ {:map :collect}) ...) :to_h)
             $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
           }
         PATTERN

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

@@ -33,7 +33,7 @@ module RuboCop
         # @!method map_to_set?(node)
         def_node_matcher :map_to_set?, <<~PATTERN
           {
-            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_set)
+            $(call (any_block $(call _ {:map :collect}) ...) :to_set)
             $(call $(call _ {:map :collect} (block_pass sym)) :to_set)
           }
         PATTERN

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -111,9 +111,7 @@ module RuboCop
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
             return false unless parent
 
-            parent.pair_type? ||
-              parent.array_type? ||
-              parent.range_type? ||
+            parent.type?(:pair, :array, :range) ||
               splat?(parent) ||
               ternary_if?(parent)
           end
@@ -128,14 +126,14 @@ module RuboCop
           end
 
           def call_in_optional_arguments?(node)
-            node.parent && (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+            node.parent&.type?(:optarg, :kwoptarg)
           end
 
           def call_in_single_line_inheritance?(node)
             node.parent&.class_type? && node.parent.single_line?
           end
 
-          # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
           def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_in_argument_with_block?(node) ||
@@ -144,33 +142,32 @@ module RuboCop
               hash_literal_in_arguments?(node) ||
               ambiguous_range_argument?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || n.block_type? || n.numblock_type? ||
+                n.type?(:forwarded_args, :any_block) ||
                   ambiguous_literal?(n) || logical_operator?(n)
               end
           end
-          # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
 
           def call_with_braced_block?(node)
-            (node.call_type? || node.super_type?) && node.block_node&.braces?
+            node.type?(:call, :super) && node.block_node&.braces?
           end
 
           def call_in_argument_with_block?(node)
             parent = node.parent&.block_type? && node.parent.parent
             return false unless parent
 
-            parent.call_type? || parent.super_type? || parent.yield_type?
+            parent.type?(:call, :super, :yield)
           end
 
           def call_as_argument_or_chain?(node)
-            node.parent &&
-              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+            node.parent&.type?(:call, :super, :yield) &&
               !assigned_before?(node.parent, node)
           end
 
           def call_in_match_pattern?(node)
             return false unless (parent = node.parent)
 
-            parent.match_pattern_type? || parent.match_pattern_p_type?
+            parent.type?(:match_pattern, :match_pattern_p)
           end
 
           def hash_literal_in_arguments?(node)
@@ -205,7 +202,7 @@ module RuboCop
           end
 
           def splat?(node)
-            node.splat_type? || node.kwsplat_type? || node.block_pass_type?
+            node.type?(:splat, :kwsplat, :block_pass)
           end
 
           def ternary_if?(node)

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

@@ -40,10 +40,8 @@ module RuboCop
         def on_send(node)
           return if ignored_node?(node)
 
-          receiver = node.receiver
-
-          return unless (receiver&.block_type? || receiver&.numblock_type?) &&
-                        receiver.loc.end.is?('end')
+          return unless (receiver = node.receiver)
+          return unless receiver.any_block_type? && receiver.loc.end.is?('end')
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -168,7 +168,7 @@ module RuboCop
 
         def anonymous_arguments?(node)
           return true if node.arguments.any? do |arg|
-            arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
+            arg.type?(:forward_arg, :restarg, :kwrestarg)
           end
           return false unless (last_argument = node.last_argument)
 

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

@@ -31,7 +31,7 @@ module RuboCop
           node.send_node.each_node(:send, :csend) do |send_node|
             receiver = send_node.receiver
 
-            next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?
+            next unless receiver&.any_block_type? && receiver.multiline?
 
             range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 

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

@@ -197,7 +197,7 @@ module RuboCop
         end
 
         def frozen_regexp_or_range_literals?(node)
-          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def unwrap_begin_nodes(node)
-          node = node.children.first while node && (node.begin_type? || node.kwbegin_type?)
+          node = node.children.first while node&.type?(:begin, :kwbegin)
 
           node
         end

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

@@ -35,7 +35,7 @@ module RuboCop
         def on_send(node)
           return unless node.parenthesized?
 
-          node.each_child_node(:send, :csend) do |nested|
+          node.each_child_node(:call) do |nested|
             next if allowed_omission?(nested)
 
             message = format(MSG, source: nested.source)

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

@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+          parent.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -69,11 +69,7 @@ module RuboCop
           elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
-          !node.array_type? || return_of_method_call?(node) || elements.any?(&:splat_type?)
-        end
-
-        def return_of_method_call?(node)
-          node.block_type? || node.send_type?
+          !node.array_type? || elements.any?(&:splat_type?)
         end
 
         def assignment_corrector(node, rhs, order)

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

@@ -94,8 +94,8 @@ module RuboCop
         end
 
         def require_parentheses?(node, condition_body)
-          return false if !node.while_type? && !node.until_type?
-          return false if !condition_body.block_type? && !condition_body.numblock_type?
+          return false unless node.type?(:while, :until)
+          return false unless condition_body.any_block_type?
 
           condition_body.send_node.block_literal? && condition_body.keywords?
         end

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

@@ -99,7 +99,7 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node.scrub
-          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
+          elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end
         end

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

@@ -19,8 +19,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?,
-                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?, '(any_block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|

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

@@ -185,7 +185,7 @@ module RuboCop
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first
 
-          first_child.rescue_type? || first_child.ensure_type?
+          first_child.type?(:rescue, :ensure)
         end
 
         def valid_context_using_only_begin?(node)

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

@@ -157,7 +157,7 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn)
         end
 
         def branches_have_method?(node)
@@ -184,7 +184,7 @@ module RuboCop
           return false unless argument.hash_type?
           return false unless (node = argument.children.first)
 
-          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+          node.type?(:kwsplat, :forwarded_kwrestarg)
         end
 
         def if_source(if_branch, arithmetic_operation)

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

@@ -25,11 +25,11 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
-          return unless parent.call_type? || parent.kwsplat_type?
+          return unless parent.type?(:call, :kwsplat)
           return unless mergeable?(parent)
           return unless (kwsplat = node.each_ancestor(:kwsplat).first)
           return if !node.braces? || allowed_double_splat_receiver?(kwsplat)
@@ -38,13 +38,13 @@ module RuboCop
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
         def allowed_double_splat_receiver?(kwsplat)
           first_child = kwsplat.children.first
-          return true if first_child.block_type? || first_child.numblock_type?
+          return true if first_child.any_block_type?
           return false unless first_child.call_type?
 
           root_receiver = root_receiver(first_child)
@@ -73,7 +73,7 @@ module RuboCop
         end
 
         def select_merge_method_nodes(kwsplat)
-          extract_send_methods(kwsplat).select do |node|
+          kwsplat.each_descendant(:call).select do |node|
             mergeable?(node)
           end
         end
@@ -89,7 +89,7 @@ module RuboCop
         def autocorrect_merge_methods(corrector, merge_methods, kwsplat)
           range = range_of_merge_methods(merge_methods)
 
-          new_kwsplat_arguments = extract_send_methods(kwsplat).map do |descendant|
+          new_kwsplat_arguments = kwsplat.each_descendant(:call).map do |descendant|
             convert_to_new_arguments(descendant)
           end
           new_source = new_kwsplat_arguments.compact.reverse.unshift('').join(', ')
@@ -104,10 +104,6 @@ module RuboCop
           begin_merge_method.loc.dot.begin.join(end_merge_method.source_range.end)
         end
 
-        def extract_send_methods(kwsplat)
-          kwsplat.each_descendant(:send, :csend)
-        end
-
         def convert_to_new_arguments(node)
           return unless mergeable?(node)
 

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

@@ -65,7 +65,7 @@ module RuboCop
           return if node.last_argument&.block_pass_type?
 
           if node.method?(:each) && !node.parent&.block_type?
-            ancestor_node = node.each_ancestor(:send, :csend).detect do |ancestor|
+            ancestor_node = node.each_ancestor(:call).detect do |ancestor|
               ancestor.receiver == node &&
                 (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
             end

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

@@ -51,7 +51,7 @@ module RuboCop
         end
 
         def string_message?(message)
-          message.str_type? || message.dstr_type? || message.xstr_type?
+          message.type?(:str, :dstr, :xstr)
         end
 
         def fix_compact(node)

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

@@ -42,7 +42,7 @@ module RuboCop
           return true if node.immutable_literal?
           return true if frozen_string_literal?(node)
 
-          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def strip_parenthesis(node)

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

@@ -50,7 +50,7 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? || parent.match_with_lvasgn_type? ||
+          parent.type?(:while_post, :until_post, :match_with_lvasgn) ||
             like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
         end
 
@@ -72,7 +72,7 @@ module RuboCop
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+          !ancestor.type?(:begin, :def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -89,7 +89,7 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+          return false unless node.type?(:send, :super, :yield)
 
           node.arguments.one? && !node.parenthesized? &&
             !node.arithmetic_operation? && node.first_argument.begin_type?
@@ -99,7 +99,7 @@ module RuboCop
           return false unless (parent = node.parent)
           return false if parent.single_line?
 
-          parent.return_type? || parent.next_type? || parent.break_type?
+          parent.type?(:return, :next, :break)
         end
 
         def empty_parentheses?(node)
@@ -279,9 +279,9 @@ module RuboCop
         end
 
         def do_end_block_in_method_chain?(begin_node, node)
-          return false unless (block = node.each_descendant(:block, :numblock).first)
+          return false unless (block = node.each_descendant(:any_block).first)
 
-          block.keywords? && begin_node.each_ancestor(:send, :csend).any?
+          block.keywords? && begin_node.each_ancestor(:call).any?
         end
       end
     end

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

@@ -21,12 +21,8 @@ module RuboCop
       #   args += foo
       #   hash.merge!(other)
       #
-      #   # bad
-      #   self.foo = foo.concat(ary)
-      #
       #   # good
       #   foo.concat(ary)
-      #   self.foo += ary
       #
       class RedundantSelfAssignment < Base
         include RangeHelp
@@ -49,6 +45,16 @@ module RuboCop
           gvasgn: :gvar
         }.freeze
 
+        # @!method redundant_self_assignment?
+        def_node_matcher :redundant_self_assignment?, <<~PATTERN
+          (call
+            %1 _
+            (call
+              (call
+                %1 %2) #method_returning_self?
+              ...))
+        PATTERN
+
         # rubocop:disable Metrics/AbcSize
         def on_lvasgn(node)
           return unless (rhs = node.rhs)
@@ -85,31 +91,10 @@ module RuboCop
           METHODS_RETURNING_SELF.include?(method_name)
         end
 
-        # @!method redundant_self_assignment?(node, method_name)
-        def_node_matcher :redundant_self_assignment?, <<~PATTERN
-          (send
-            (self) _
-            (call
-              (send
-                {(self) nil?} %1) #method_returning_self?
-              ...))
-        PATTERN
-
-        # @!method redundant_nonself_assignment?(node, receiver, method_name)
-        def_node_matcher :redundant_nonself_assignment?, <<~PATTERN
-          (call
-            %1 _
-            (call
-              (call
-                %1 %2) #method_returning_self?
-              ...))
-        PATTERN
-
         def redundant_assignment?(node)
-          receiver_name = node.method_name.to_s[0...-1].to_sym
+          receiver_name = node.method_name.to_s.delete_suffix('=').to_sym
 
-          redundant_self_assignment?(node, receiver_name) ||
-            redundant_nonself_assignment?(node, node.receiver, receiver_name)
+          redundant_self_assignment?(node, node.receiver, receiver_name)
         end
 
         def correction_range(node)

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

@@ -93,9 +93,9 @@ module RuboCop
             (call $(call _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (call ({block numblock} $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call (any_block $(call _ ${:sort_by :sort}) ...) ${:last :first})
             (call
-              ({block numblock} $(call _ ${:sort_by :sort}) ...)
+              (any_block $(call _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }

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

@@ -41,7 +41,7 @@ module RuboCop
         MSG = 'Redundant escape of %<char>s inside string literal.'
 
         def on_str(node)
-          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+          return if node.parent&.type?(:regexp, :xstr) || node.character_literal?
 
           str_contents_range = str_contents_range(node)
 
@@ -147,7 +147,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def delimiter?(node, char)