rubocop 1.71.0 → 1.71.2

data/lib/rubocop/cop/lint/void.rb

@@ -103,7 +103,7 @@ module RuboCop
           expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
             check_void_op(expr) do
-              block_node = node.each_ancestor(:block).first
+              block_node = node.each_ancestor(:any_block).first
 
               block_node&.method?(:each)
             end
@@ -179,7 +179,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return if !node.send_type? && !node.block_type? && !node.numblock_type?
+          return unless node.type?(:send, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -201,11 +201,6 @@ module RuboCop
           # NOTE: the `begin` node case is already handled via `on_begin`
           return if body.begin_type?
 
-          check_void_op(body) do
-            block_node = node.each_ancestor(:block).first
-            block_node&.method?(:each)
-          end
-
           check_expression(body)
         end
 

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -52,7 +52,7 @@ module RuboCop
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && (node.block_type? || node.numblock_type?)
+          count_blocks? && node.any_block_type?
         end
 
         def message(max)

data/lib/rubocop/cop/metrics/module_length.rb

@@ -50,7 +50,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -50,7 +50,7 @@ module RuboCop
           return extract_breakable_node_from_elements(node, args, max)
         elsif node.def_type?
           return extract_breakable_node_from_elements(node, node.arguments, max)
-        elsif node.array_type? || node.hash_type?
+        elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
         end
         nil
@@ -101,7 +101,7 @@ module RuboCop
       # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.call_type? || node.array_type?
+        return index unless node.type?(:call, :array)
 
         heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
@@ -154,7 +154,7 @@ module RuboCop
           # Ignore ancestors on different lines.
           break if ancestor.first_line != node.first_line
 
-          if ancestor.hash_type? || ancestor.array_type?
+          if ancestor.type?(:hash, :array)
             elements = ancestor.children
           elsif ancestor.call_type?
             elements = process_args(ancestor.arguments)
@@ -171,7 +171,7 @@ module RuboCop
       # @api private
       def contained_by_multiline_collection_that_could_be_broken_up?(node)
         node.each_ancestor.find do |ancestor|
-          if (ancestor.hash_type? || ancestor.array_type?) &&
+          if ancestor.type?(:hash, :array) &&
              breakable_collection?(ancestor, ancestor.children)
             return children_could_be_broken_up?(ancestor.children)
           end
@@ -227,7 +227,7 @@ module RuboCop
 
       def chained_to_heredoc?(node)
         while (node = node.receiver)
-          return true if (node.str_type? || node.dstr_type? || node.xstr_type?) && node.heredoc?
+          return true if node.type?(:str, :dstr, :xstr) && node.heredoc?
         end
 
         false

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -76,7 +76,7 @@ module RuboCop
           elsif node.if? && node.parent && parentheses?(node.parent)
             node.parent.loc.end.line
           end
-        elsif node.block_type? || node.numblock_type?
+        elsif node.any_block_type?
           node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node) &&
               next_sibling.source_range

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -86,7 +86,7 @@ module RuboCop
         return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
-        return true unless hash_value.send_type? || hash_value.lvar_type?
+        return true unless hash_value.type?(:send, :lvar)
 
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
@@ -109,7 +109,7 @@ module RuboCop
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
         return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
+        def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
@@ -117,7 +117,7 @@ module RuboCop
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
-        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return unless ancestor.type?(:call, :super, :yield)
         return if brackets?(ancestor)
 
         ancestor
@@ -150,7 +150,7 @@ module RuboCop
         parent = method_dispatch_node.parent
         return false unless parent
 
-        parent.call_type? || parent.super_type? || parent.yield_type?
+        parent.type?(:call, :super, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -5,6 +5,7 @@ module RuboCop
     # Common functionality for Style/HashExcept and Style/HashSlice cops.
     # It registers an offense on methods with blocks that are equivalent
     # to Hash#except or Hash#slice.
+    # rubocop:disable Metrics/ModuleLength
     module HashSubset
       include RangeHelp
       extend NodePattern::Macros
@@ -67,7 +68,11 @@ module RuboCop
 
       def extracts_hash_subset?(block)
         block_with_first_arg_check?(block) do |key_arg, send_node, method|
+          # Only consider methods that have one argument
+          return false unless send_node.arguments.one?
+
           return false unless supported_subset_method?(method)
+          return false if range_include?(send_node)
 
           case method
           when :include?, :exclude?
@@ -80,6 +85,18 @@ module RuboCop
         end
       end
 
+      def range_include?(send_node)
+        # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
+        # or first argument is a range, an offense should not be registered.
+        # ie. `(1..5).include?(k)` or `k.in?('a'..'z')`
+
+        return true if send_node.first_argument.range_type?
+
+        receiver = send_node.receiver
+        receiver = receiver.child_nodes.first while receiver.begin_type?
+        receiver.range_type?
+      end
+
       def supported_subset_method?(method)
         if active_support_extensions_enabled?
           ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
@@ -119,7 +136,7 @@ module RuboCop
         body = block.body
 
         if body.method?('==') || body.method?('!=')
-          except_key.sym_type? || except_key.str_type?
+          except_key.type?(:sym, :str)
         else
           true
         end
@@ -166,5 +183,6 @@ module RuboCop
         range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -35,7 +35,7 @@ module RuboCop
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        ({block numblock}
+        (any_block
          (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
+    # rubocop:disable Metrics/ModuleLength
     module PrecedingFollowingAlignment
       # Tokens that end with an `=`, as well as `<<`, that can be aligned together:
       # `=`, `==`, `===`, `!=`, `<=`, `>=`, `<<` and operator assignment (`+=`, etc).
@@ -156,10 +157,14 @@ module RuboCop
         @assignment_tokens ||= begin
           tokens = processed_source.tokens.select(&:equal_sign?)
 
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
+          # We don't want to operate on equals signs which are part of an `optarg` in a
+          # method definition, or the separator of an endless method definition.
+          # For example (the equals sign to ignore is highlighted with ^):
+          #     def method(optarg = default_val); end
+          #                       ^
+          #     def method = foo
+          #                ^
+          tokens = remove_equals_in_def(tokens, processed_source)
 
           # Only attempt to align the first = on each line
           Set.new(tokens.uniq(&:line))
@@ -195,11 +200,20 @@ module RuboCop
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
 
-      def remove_optarg_equals(asgn_tokens, processed_source)
-        optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.to_set { |o| o.loc.operator.begin_pos }
-        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      def remove_equals_in_def(asgn_tokens, processed_source)
+        nodes = processed_source.ast.each_node(:optarg, :def)
+        eqls_to_ignore = nodes.with_object([]) do |node, arr|
+          loc = if node.def_type?
+                  node.loc.assignment if node.endless?
+                else
+                  node.loc.operator
+                end
+          arr << loc.begin_pos if loc
+        end
+
+        asgn_tokens.reject { |t| eqls_to_ignore.include?(t.begin_pos) }
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -33,7 +33,7 @@ module RuboCop
         # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
         node.ancestors
             .drop_while { |a| !a.begin_type? }
-            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
+            .any? { |a| a.type?(:dstr, :dsym, :regexp) }
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -181,7 +181,7 @@ module RuboCop
         #       ...
         #     SOURCE
         #   })
-        return heredoc?(node.children.last) if node.pair_type? || node.hash_type?
+        return heredoc?(node.children.last) if node.type?(:pair, :hash)
 
         false
       end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -13,6 +13,20 @@ module RuboCop
       # The default variable name is `block`. If the name is already in use, it will not be
       # autocorrected.
       #
+      # [NOTE]
+      # --
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # --
+      #
       # @example EnforcedStyle: anonymous (default)
       #
       #   # bad
@@ -90,21 +104,11 @@ module RuboCop
           last_argument.source == block_pass_node.source
         end
 
-        # Prevents the following syntax error:
-        #
-        # # foo.rb
-        # def foo(&)
-        #   block_method do
-        #     bar(&)
-        #   end
-        # end
-        #
-        # $ ruby -vc foo.rb
-        # ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [x86_64-darwin22]
-        # foo.rb: foo.rb:4: anonymous block parameter is also used within block (SyntaxError)
-        #
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
         def invalidates_syntax?(block_pass_node)
-          block_pass_node.each_ancestor(:block, :numblock).any?
+          target_ruby_version <= 3.3 && block_pass_node.each_ancestor(:any_block).any?
         end
 
         def use_kwarg_in_method_definition?(node)

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -113,7 +113,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/MethodLength
         def correct_node(corrector, node, offending_name, preferred_name)
           return unless node
 
@@ -129,13 +129,13 @@ module RuboCop
               end
             end
 
-            if child_node.masgn_type? || child_node.lvasgn_type?
+            if child_node.type?(:masgn, :lvasgn)
               correct_reassignment(corrector, child_node, offending_name, preferred_name)
               break
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/MethodLength
 
         # If the exception variable is reassigned, that assignment needs to be corrected.
         # Further `lvar` nodes will not be corrected though since they now refer to a

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

@@ -150,8 +150,6 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
-        ALLOWED_NODE_TYPES = %i[pair block].freeze
-
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public :module_function}
@@ -188,7 +186,7 @@ module RuboCop
 
         def allowed?(node)
           !node.access_modifier? ||
-            ALLOWED_NODE_TYPES.include?(node.parent&.type) ||
+            node.parent&.type?(:pair, :any_block) ||
             allow_modifiers_on_symbols?(node) ||
             allow_modifiers_on_attrs?(node) ||
             allow_modifiers_on_alias_method?(node)
@@ -312,7 +310,7 @@ module RuboCop
           argument_less_modifier_node = find_argument_less_modifier_node(node)
           if argument_less_modifier_node
             corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
-          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+          elsif (ancestor = node.each_ancestor(:class, :module).first)
 
             corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else

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

@@ -31,6 +31,20 @@ module RuboCop
       #
       # This cop handles not only method forwarding but also forwarding to `super`.
       #
+      # [NOTE]
+      # --
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # --
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -148,7 +162,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
+          send_nodes = node.each_descendant(:call, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -191,9 +205,7 @@ module RuboCop
 
           send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
             if !forward_rest && !forward_kwrest && c != :all_anonymous
-              # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-              # in Ruby 3.3.0.
-              if outside_block?(forward_block_arg)
+              if allow_anonymous_forwarding_in_block?(forward_block_arg)
                 register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
                 register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
               end
@@ -214,24 +226,22 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
-          return if send_inside_block?(send_classifications)
+          return unless all_forwarding_offenses_correctable?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
           send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if outside_block?(forward_rest)
+            if allow_anonymous_forwarding_in_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if outside_block?(forward_kwrest)
+            if allow_anonymous_forwarding_in_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
 
-            # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-            # in Ruby 3.3.0.
-            if outside_block?(forward_block_arg)
+            if allow_anonymous_forwarding_in_block?(forward_block_arg)
               register_forward_block_arg_offense(!forward_rest, def_node.arguments, block_arg)
               register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
             end
@@ -293,10 +303,25 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
-        def outside_block?(node)
+        # Checks if forwarding is uses both in blocks and outside of blocks.
+        # On Ruby 3.3.0, anonymous block forwarding in blocks can be is a syntax
+        # error, so we only want to register an offense if we can change all occurrences.
+        def all_forwarding_offenses_correctable?(send_classifications)
+          return true if target_ruby_version >= 3.4
+
+          send_classifications.none? do |send_node, *|
+            send_node.each_ancestor(:any_block).any?
+          end
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def allow_anonymous_forwarding_in_block?(node)
           return false unless node
+          return true if target_ruby_version >= 3.4
 
-          node.each_ancestor(:block, :numblock).none?
+          node.each_ancestor(:any_block).none?
         end
 
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
@@ -357,12 +382,6 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
-        def send_inside_block?(send_classifications)
-          send_classifications.any? do |send_node, *|
-            send_node.each_ancestor(:block, :numblock).any?
-          end
-        end
-
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
           return if node.send_type? && node.method?(:[])
@@ -511,7 +530,7 @@ module RuboCop
           end
 
           def additional_kwargs?
-            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+            @def_node.arguments.any? { |a| a.type?(:kwarg, :kwoptarg) }
           end
 
           def forward_additional_kwargs?

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

@@ -481,7 +481,7 @@ module RuboCop
         end
 
         def array_or_range?(node)
-          node.array_type? || node.range_type?
+          node.type?(:array, :range)
         end
 
         def begin_required?(block_node)

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

@@ -161,7 +161,7 @@ module RuboCop
 
         def check_compact_style(node, body)
           parent = node.parent
-          return if parent&.class_type? || parent&.module_type?
+          return if parent&.type?(:class, :module)
 
           return unless needs_compacting?(body)
 

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

@@ -55,7 +55,7 @@ module RuboCop
         def defined_calls(nodes)
           nodes.filter_map do |defined_node|
             subject = defined_node.first_argument
-            subject if subject.const_type? || subject.call_type?
+            subject if subject.type?(:const, :call)
           end
         end
 

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

@@ -98,7 +98,7 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+          return false if sibling.nil? || !sibling.any_block_type?
 
           sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
@@ -118,7 +118,7 @@ module RuboCop
 
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.block_type? || node.right_sibling&.numblock_type?
+          return if node.right_sibling&.any_block_type?
 
           end_of_block = node.left_sibling.braces? ? '}' : ' end'
           corrector.remove(node.loc.end)

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

@@ -86,7 +86,7 @@ module RuboCop
 
         def percent_literals_includes_only_basic_literals?(node)
           node.arguments.select(&:percent_literal?).all? do |arg|
-            arg.children.all? { |child| child.str_type? || child.sym_type? }
+            arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
       end

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

@@ -107,7 +107,7 @@ module RuboCop
           parent = node.parent
           return true unless parent
 
-          !(parent.mlhs_type? || parent.resbody_type?)
+          !parent.type?(:mlhs, :resbody)
         end
       end
 
@@ -326,7 +326,7 @@ module RuboCop
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type? || node.case_match_type?
+          if node.type?(:case, :case_match)
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -340,7 +340,7 @@ module RuboCop
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type? || condition.case_match_type?
+          elsif condition.type?(:case, :case_match)
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)

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

@@ -186,7 +186,7 @@ module RuboCop
         def qualify_const(node)
           return if node.nil?
 
-          if node.cbase_type? || node.self_type? || node.call_type? || node.variable?
+          if node.type?(:cbase, :self, :call) || node.variable?
             node.source
           else
             [qualify_const(node.namespace), node.short_name].compact

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

@@ -93,7 +93,7 @@ module RuboCop
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
-          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+          elsif last_child.type?(:pair, :hash) || last_child.parent.array_type?
             false
           else
             last_child.last_line <= node.last_line
@@ -102,7 +102,7 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.def_type? || parent.defs_type?
+          return parent if parent.type?(:def, :defs)
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)
@@ -147,7 +147,7 @@ module RuboCop
         def find_parent_not_enumerable(node)
           return unless (parent = node.parent)
 
-          if parent.pair_type? || parent.hash_type? || parent.array_type?
+          if parent.type?(:pair, :hash, :array)
             find_parent_not_enumerable(parent)
           else
             parent

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

@@ -58,7 +58,7 @@ module RuboCop
 
         # @!method each_with_object_block_candidate?(node)
         def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
-          (block $(call _ {:inject :reduce} _) $_ $_)
+          (block $(call _ {:inject :reduce} _) $(args _ _) $_)
         PATTERN
 
         # @!method each_with_object_numblock_candidate?(node)
@@ -71,8 +71,7 @@ module RuboCop
 
           first_arg, second_arg = *node.arguments
 
-          corrector.replace(first_arg, second_arg.source)
-          corrector.replace(second_arg, first_arg.source)
+          corrector.swap(first_arg, second_arg)
 
           if return_value_occupies_whole_line?(return_value)
             corrector.remove(whole_line_expression(return_value))

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

@@ -86,7 +86,7 @@ module RuboCop
           return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
 
           code = node.first_argument
-          return unless code && (code.str_type? || code.dstr_type?)
+          return unless code&.type?(:str, :dstr)
 
           check_location(node, code)
         end