rubocop 1.57.1 → 1.65.0

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

@@ -67,12 +67,13 @@ module RuboCop
           return unless redundant_argument?(node)
 
           offense_range = argument_range(node)
-          message = format(MSG, arg: node.arguments.first.source)
+          message = format(MSG, arg: node.first_argument.source)
 
           add_offense(offense_range, message: message) do |corrector|
             corrector.remove(offense_range)
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -80,14 +81,20 @@ module RuboCop
           redundant_argument = redundant_arg_for_method(node.method_name.to_s)
           return false if redundant_argument.nil?
 
-          node.arguments.first == redundant_argument
+          target_argument = if node.first_argument.respond_to?(:value)
+                              node.first_argument.value
+                            else
+                              node.first_argument
+                            end
+
+          argument_matched?(target_argument, redundant_argument)
         end
 
         def redundant_arg_for_method(method_name)
           arg = cop_config['Methods'].fetch(method_name) { return }
 
           @mem ||= {}
-          @mem[method_name] ||= parse(arg.inspect).ast
+          @mem[method_name] ||= arg.inspect
         end
 
         def argument_range(node)
@@ -97,6 +104,23 @@ module RuboCop
             range_with_surrounding_space(node.first_argument.source_range, newlines: false)
           end
         end
+
+        def argument_matched?(target_argument, redundant_argument)
+          argument = if target_argument.is_a?(AST::Node)
+                       target_argument.source
+                     elsif exclude_cntrl_character?(target_argument, redundant_argument)
+                       target_argument.inspect
+                     else
+                       target_argument.to_s
+                     end
+
+          argument == redundant_argument
+        end
+
+        def exclude_cntrl_character?(target_argument, redundant_argument)
+          !target_argument.to_s.sub(/\A'/, '"').sub(/'\z/, '"').match?(/[[:cntrl:]]/) ||
+            !redundant_argument.match?(/[[:cntrl:]]/)
+        end
       end
     end
   end

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

@@ -54,12 +54,14 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
           return unless node
 
           case node.type
-          when :case   then check_case_node(node)
-          when :if     then check_if_node(node)
+          when :case       then check_case_node(node)
+          when :case_match then check_case_match_node(node)
+          when :if         then check_if_node(node)
           when :rescue, :resbody
             check_rescue_node(node)
           when :ensure then check_ensure_node(node)
@@ -67,12 +69,18 @@ module RuboCop
             check_begin_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_case_node(node)
           node.when_branches.each { |when_node| check_branch(when_node.body) }
           check_branch(node.else_branch)
         end
 
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
         def check_if_node(node)
           return if node.modifier_form? || node.ternary?
 

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

@@ -75,7 +75,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
-          return if node.endless? && !node.body.children.one?
+          return if node.endless?
 
           register_offense(node.body)
         end

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

@@ -18,14 +18,15 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant current directory path.'
+        RESTRICT_ON_SEND = %i[require_relative].freeze
         CURRENT_DIRECTORY_PATH = './'
 
         def on_send(node)
-          return unless node.method?(:require_relative)
-          return unless node.first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
-          return unless (index = node.first_argument.source.index(CURRENT_DIRECTORY_PATH))
+          return unless (first_argument = node.first_argument)
+          return unless first_argument.str_content&.start_with?(CURRENT_DIRECTORY_PATH)
+          return unless (index = first_argument.source.index(CURRENT_DIRECTORY_PATH))
 
-          begin_pos = node.first_argument.source_range.begin.begin_pos + index
+          begin_pos = first_argument.source_range.begin.begin_pos + index
           range = range_between(begin_pos, begin_pos + 2)
 
           add_offense(range) do |corrector|

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

@@ -25,26 +25,29 @@ module RuboCop
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
         MERGE_METHODS = %i[merge merge!].freeze
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
-          return if parent.call_type? && !merge_method?(parent)
+          return unless parent.call_type? || parent.kwsplat_type?
+          return unless mergeable?(parent)
           return unless (kwsplat = node.each_ancestor(:kwsplat).first)
-          return if allowed_double_splat_receiver?(kwsplat)
+          return if !node.braces? || allowed_double_splat_receiver?(kwsplat)
 
           add_offense(kwsplat) do |corrector|
             autocorrect(corrector, node, kwsplat)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
         def allowed_double_splat_receiver?(kwsplat)
-          return false unless kwsplat.children.first.call_type?
+          first_child = kwsplat.children.first
+          return true if first_child.block_type? || first_child.numblock_type?
+          return false unless first_child.call_type?
 
-          root_receiver = root_receiver(kwsplat.children.first)
+          root_receiver = root_receiver(first_child)
 
           !root_receiver&.hash_type?
         end
@@ -71,7 +74,7 @@ module RuboCop
 
         def select_merge_method_nodes(kwsplat)
           extract_send_methods(kwsplat).select do |node|
-            merge_method?(node)
+            mergeable?(node)
           end
         end
 
@@ -106,7 +109,7 @@ module RuboCop
         end
 
         def convert_to_new_arguments(node)
-          return unless merge_method?(node)
+          return unless mergeable?(node)
 
           node.arguments.map do |arg|
             if arg.hash_type?
@@ -117,8 +120,12 @@ module RuboCop
           end
         end
 
-        def merge_method?(node)
-          MERGE_METHODS.include?(node.method_name)
+        def mergeable?(node)
+          return true unless node.call_type?
+          return false unless MERGE_METHODS.include?(node.method_name)
+          return true unless (parent = node.parent)
+
+          mergeable?(parent)
         end
       end
     end

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

@@ -56,6 +56,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -64,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).detect do |ancestor|
+            ancestor_node = node.each_ancestor(:send, :csend).detect do |ancestor|
               ancestor.receiver == node &&
                 (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
             end
@@ -83,10 +84,12 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def range(node)
-          if node.method?(:each)
-            node.loc.dot.join(node.loc.selector)
+          return node.selector unless node.method?(:each)
+
+          if node.parent&.call_type?
+            node.selector.join(node.parent.loc.dot)
           else
-            node.loc.selector
+            node.loc.dot.join(node.selector)
           end
         end
 

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

@@ -47,7 +47,7 @@ module RuboCop
         # @!method redundant_fetch_block_candidate?(node)
         def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
           (block
-            $(send _ :fetch _)
+            $(call _ :fetch _)
             (args)
             ${nil? #basic_literal? #const_type?})
         PATTERN
@@ -61,10 +61,10 @@ module RuboCop
             bad = build_bad_method(send, body)
 
             add_offense(range, message: format(MSG, good: good, bad: bad)) do |corrector|
-              receiver, _, key = send.children
+              _, _, key = send.children
               default_value = body ? body.source : 'nil'
 
-              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
+              corrector.replace(range, "fetch(#{key.source}, #{default_value})")
             end
           end
         end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for the presence of superfluous `.rb` extension in
       # the filename provided to `require` and `require_relative`.
       #
-      # Note: If the extension is omitted, Ruby tries adding '.rb', '.so',
+      # NOTE: If the extension is omitted, Ruby tries adding '.rb', '.so',
       #       and so on to the name until found. If the file named cannot be found,
       #       a `LoadError` will be raised.
       #       There is an edge case where `foo.so` file is loaded instead of a `LoadError`

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

@@ -60,10 +60,10 @@ module RuboCop
 
         # @!method select_predicate?(node)
         def_node_matcher :select_predicate?, <<~PATTERN
-          (send
+          (call
             {
-              (block $(send _ {:select :filter :find_all}) ...)
-              $(send _ {:select :filter :find_all} block_pass_type?)
+              (block $(call _ {:select :filter :find_all}) ...)
+              $(call _ {:select :filter :find_all} block_pass_type?)
             }
             ${:#{RESTRICT_ON_SEND.join(' :')}})
         PATTERN
@@ -79,7 +79,7 @@ module RuboCop
         private_constant :REPLACEMENT_METHODS
 
         def on_send(node)
-          return if node.arguments? || node.block_node
+          return if node.arguments? || node.block_literal?
 
           select_predicate?(node) do |select_node, filter_method|
             return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?
@@ -87,6 +87,7 @@ module RuboCop
             register_offense(select_node, node)
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -74,6 +74,7 @@ module RuboCop
           kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
           tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
         ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -94,7 +95,8 @@ module RuboCop
           !ends_with_backslash_without_comment?(range.source_line) ||
             string_concatenation?(range.source_line) ||
             start_with_arithmetic_operator?(processed_source[range.line]) ||
-            inside_string_literal_or_method_with_argument?(range)
+            inside_string_literal_or_method_with_argument?(range) ||
+            leading_dot_method_chain_with_blank_line?(range)
         end
 
         def ends_with_backslash_without_comment?(source_line)
@@ -107,10 +109,18 @@ module RuboCop
 
         def inside_string_literal_or_method_with_argument?(range)
           processed_source.tokens.each_cons(2).any? do |token, next_token|
+            next if token.line == next_token.line
+
             inside_string_literal?(range, token) || method_with_argument?(token, next_token)
           end
         end
 
+        def leading_dot_method_chain_with_blank_line?(range)
+          return false unless range.source_line.strip.start_with?('.', '&.')
+
+          processed_source[range.line].strip.empty?
+        end
+
         def redundant_line_continuation?(range)
           return true unless (node = find_node_for_line(range.line))
           return false if argument_newline?(node)
@@ -128,10 +138,16 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+
+          ARGUMENT_TYPES.include?(next_token.type)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
+          node = node.to_a.last if node.assignment?
+          return false if node.parenthesized_call?
+
           node = node.children.first if node.root? && node.begin_type?
 
           if argument_is_method?(node)
@@ -142,6 +158,7 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(line)
           processed_source.ast.each_node do |node|

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

@@ -17,12 +17,11 @@ module RuboCop
         include Parentheses
         extend AutoCorrector
 
+        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+
         # @!method square_brackets?(node)
         def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
 
-        # @!method range_end?(node)
-        def_node_matcher :range_end?, '^^{irange erange}'
-
         # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
 
@@ -54,15 +53,16 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? ||
-            like_method_argument_parentheses?(parent)
+          parent.while_post_type? || parent.until_post_type? || parent.match_with_lvasgn_type? ||
+            like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
         end
 
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
             allowed_multiple_expression?(node) ||
-            allowed_ternary?(node)
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
         end
 
         def allowed_ancestor?(node)
@@ -104,6 +104,13 @@ module RuboCop
             !node.arithmetic_operation? && node.first_argument.begin_type?
         end
 
+        def multiline_control_flow_statements?(node)
+          return false unless (parent = node.parent)
+          return false if parent.single_line?
+
+          parent.return_type? || parent.next_type? || parent.break_type?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -111,17 +118,19 @@ module RuboCop
 
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          method_chain_begins_with_hash_literal?(node.children.first) &&
-            first_argument?(node) &&
-            !parentheses?(node.parent)
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
-        def method_chain_begins_with_hash_literal?(node)
-          return false if node.nil?
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
 
-          method_chain_begins_with_hash_literal?(node.children.first)
+          method_chain_begins_with_hash_literal(node.children.first)
         end
 
         def check(begin_node)
@@ -134,27 +143,44 @@ module RuboCop
           check_send(begin_node, node) if node.call_type?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
           return 'a literal' if disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
           return 'an interpolated expression' if interpolation?(begin_node)
 
-          return if begin_node.chained? || !begin_node.parent.nil?
+          return if begin_node.chained?
 
           if node.and_type? || node.or_type?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
             'a comparison expression'
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def allow_in_multiline_conditions?
+          parentheses_around_condition_config = config.for_cop('Style/ParenthesesAroundCondition')
+          return false unless parentheses_around_condition_config['Enabled']
+
+          !!parentheses_around_condition_config['AllowInMultilineConditions']
+        end
+
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 
@@ -219,7 +245,6 @@ module RuboCop
         def method_call_with_redundant_parentheses?(node)
           return false unless node.call_type?
           return false if node.prefix_not?
-          return false if range_end?(node)
 
           send_node, args = method_node_and_args(node)
 
@@ -231,7 +256,13 @@ module RuboCop
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
         # @!method first_send_argument?(node)

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

@@ -53,7 +53,7 @@ module RuboCop
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
           add_offense(node) do |corrector|
-            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
 
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)

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

@@ -58,7 +58,7 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
-        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
 
         def on_send(node)
           return unless (parent = node.parent) && parent.block_type?
@@ -113,6 +113,7 @@ module RuboCop
           case node.type
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
+          when :case_match then check_case_match_node(node)
           when :if     then check_if_node(node)
           when :rescue then check_rescue_node(node)
           when :resbody then check_resbody_node(node)
@@ -140,6 +141,11 @@ module RuboCop
           check_branch(node.else_branch)
         end
 
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
         def check_if_node(node)
           return if node.ternary?
 

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

@@ -17,7 +17,8 @@ module RuboCop
       # protected scope, you cannot send private messages this way.
       #
       # Note we allow uses of `self` with operators because it would be awkward
-      # otherwise.
+      # otherwise. Also allows the use of `self.it` without arguments in blocks,
+      # as in `0.times { self.it }`, following `Lint/ItWithoutArgumentsInBlock` cop.
       #
       # @example
       #
@@ -107,8 +108,8 @@ module RuboCop
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent&.mlhs_type?
-
           return if allowed_send_node?(node)
+          return if it_method_in_block?(node)
 
           add_offense(node.receiver) do |corrector|
             corrector.remove(node.receiver)
@@ -155,6 +156,20 @@ module RuboCop
             KERNEL_METHODS.include?(node.method_name)
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          node.arguments.empty? && !node.block_literal?
+        end
+
         def regular_method_call?(node)
           !(node.operator_method? ||
             KEYWORDS.include?(node.method_name) ||

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

@@ -16,7 +16,7 @@ module RuboCop
       #   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`,
+      #   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
@@ -87,15 +87,15 @@ module RuboCop
         # @!method redundant_sort?(node)
         def_node_matcher :redundant_sort?, <<~MATCHER
           {
-            (send $(send _ $:sort) ${:last :first})
-            (send $(send _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
+            (call $(call _ $:sort) ${:last :first})
+            (call $(call _ $:sort) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send $(send _ $:sort_by _) ${:last :first})
+            (call $(call _ $:sort_by _) ${:last :first})
             (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
 
-            (send ({block numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
-            (send
-              ({block numblock} $(send _ ${:sort_by :sort}) ...)
+            (call ({block numblock} $(call _ ${:sort_by :sort}) ...) ${:last :first})
+            (call
+              ({block numblock} $(call _ ${:sort_by :sort}) ...)
               ${:[] :at :slice} {(int 0) (int -1)}
             )
           }
@@ -108,6 +108,7 @@ module RuboCop
 
           register_offense(ancestor, sort_node, sorter, accessor)
         end
+        alias on_csend on_send
 
         private
 
@@ -180,7 +181,7 @@ module RuboCop
         end
 
         def arg_node(node)
-          node.arguments.first
+          node.first_argument
         end
 
         def arg_value(node)

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

@@ -46,12 +46,12 @@ module RuboCop
 
         # @!method redundant_sort_by_block(node)
         def_node_matcher :redundant_sort_by_block, <<~PATTERN
-          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+          (block $(call _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 
         # @!method redundant_sort_by_numblock(node)
         def_node_matcher :redundant_sort_by_numblock, <<~PATTERN
-          (numblock $(send _ :sort_by) 1 (lvar :_1))
+          (numblock $(call _ :sort_by) 1 (lvar :_1))
         PATTERN
 
         def sort_by_range(send, node)

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

@@ -133,7 +133,7 @@ module RuboCop
         end
 
         def percent_array_literal?(node)
-          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+          percent_w_literal?(node) || percent_w_upper_literal?(node)
         end
 
         def heredoc_with_disabled_interpolation?(node)

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
         end
       end
     end