rubocop 1.67.0 → 1.75.7

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for calls to `Kernel#format` or `Kernel#sprintf` that are redundant.
+      #
+      # Calling `format` with only a single string or constant argument is redundant,
+      # as it can be replaced by the string or constant itself.
+      #
+      # Also looks for `format` calls where the arguments are literals that can be
+      # inlined into a string easily. This applies to the `%s`, `%d`, `%i`, `%u`, and
+      # `%f` format specifiers.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because string object returned by
+      #   `format` and `sprintf` are never frozen. If `format('string')` is autocorrected to
+      #   `'string'`, `FrozenError` may occur when calling a destructive method like `String#<<`.
+      #   Consider using `'string'.dup` instead of `format('string')`.
+      #   Additionally, since the necessity of `dup` cannot be determined automatically,
+      #   this autocorrection is inherently unsafe.
+      #
+      #   [source,ruby]
+      #   ----
+      #   # frozen_string_literal: true
+      #
+      #   format('template').frozen? # => false
+      #   'template'.frozen?         # => true
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   format('the quick brown fox jumps over the lazy dog.')
+      #   sprintf('the quick brown fox jumps over the lazy dog.')
+      #
+      #   # good
+      #   'the quick brown fox jumps over the lazy dog.'
+      #
+      #   # bad
+      #   format(MESSAGE)
+      #   sprintf(MESSAGE)
+      #
+      #   # good
+      #   MESSAGE
+      #
+      #   # bad
+      #   format('%s %s', 'foo', 'bar')
+      #   sprintf('%s %s', 'foo', 'bar')
+      #
+      #   # good
+      #   'foo bar'
+      #
+      class RedundantFormat < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` directly instead of `%<method_name>s`.'
+
+        RESTRICT_ON_SEND = %i[format sprintf].to_set.freeze
+        ACCEPTABLE_LITERAL_TYPES = %i[str dstr sym dsym numeric boolean nil].freeze
+
+        # @!method format_without_additional_args?(node)
+        def_node_matcher :format_without_additional_args?, <<~PATTERN
+          (send {(const {nil? cbase} :Kernel) nil?} %RESTRICT_ON_SEND ${str dstr const})
+        PATTERN
+
+        # @!method rational_number?(node)
+        def_node_matcher :rational_number?, <<~PATTERN
+          {rational (send int :/ rational) (begin rational) (begin (send int :/ rational))}
+        PATTERN
+
+        # @!method complex_number?(node)
+        def_node_matcher :complex_number?, <<~PATTERN
+          {complex (send int :+ complex) (begin complex) (begin (send int :+ complex))}
+        PATTERN
+
+        # @!method find_hash_value_node(node, name)
+        def_node_search  :find_hash_value_node, <<~PATTERN
+          (pair (sym %1) $_)
+        PATTERN
+
+        # @!method splatted_arguments?(node)
+        def_node_matcher :splatted_arguments?, <<~PATTERN
+          (send _ %RESTRICT_ON_SEND <{
+            splat
+            (hash <kwsplat ...>)
+          } ...>)
+        PATTERN
+
+        def on_send(node)
+          format_without_additional_args?(node) do |value|
+            replacement = value.source
+
+            add_offense(node, message: message(node, replacement)) do |corrector|
+              corrector.replace(node, replacement)
+            end
+            return
+          end
+
+          detect_unnecessary_fields(node)
+        end
+
+        private
+
+        def message(node, prefer)
+          format(MSG, prefer: prefer, method_name: node.method_name)
+        end
+
+        def detect_unnecessary_fields(node)
+          return unless node.first_argument&.str_type?
+
+          string = node.first_argument.value
+          arguments = node.arguments[1..]
+
+          return unless string && arguments.any?
+          return if splatted_arguments?(node)
+
+          register_all_fields_literal(node, string, arguments)
+        end
+
+        def register_all_fields_literal(node, string, arguments)
+          return unless all_fields_literal?(string, arguments.dup)
+
+          formatted_string = format(string, *argument_values(arguments))
+          replacement = quote(formatted_string, node)
+
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def all_fields_literal?(string, arguments)
+          count = 0
+          sequences = RuboCop::Cop::Utils::FormatString.new(string).format_sequences
+          return false unless sequences.any?
+
+          sequences.each do |sequence|
+            next if sequence.percent?
+
+            hash = arguments.detect(&:hash_type?)
+            next unless (argument = find_argument(sequence, arguments, hash))
+            next unless matching_argument?(sequence, argument)
+
+            count += 1
+          end
+
+          sequences.size == count
+        end
+
+        def find_argument(sequence, arguments, hash)
+          if hash && (sequence.annotated? || sequence.template?)
+            find_hash_value_node(hash, sequence.name.to_sym).first
+          elsif sequence.arg_number
+            arguments[sequence.arg_number.to_i - 1]
+          else
+            # If the specifier contains `*`, the following arguments will be used
+            # to specify the width and can be ignored.
+            (sequence.arity - 1).times { arguments.shift }
+            arguments.shift
+          end
+        end
+
+        def matching_argument?(sequence, argument)
+          # Template specifiers don't give a type, any acceptable literal type is ok.
+          return argument.type?(*ACCEPTABLE_LITERAL_TYPES) if sequence.template?
+
+          # An argument matches a specifier if it can be easily converted
+          # to that type.
+          case sequence.type
+          when 's'
+            argument.type?(*ACCEPTABLE_LITERAL_TYPES)
+          when 'd', 'i', 'u'
+            integer?(argument)
+          when 'f'
+            float?(argument)
+          else
+            false
+          end
+        end
+
+        def numeric?(argument)
+          argument.type?(:numeric, :str) ||
+            rational_number?(argument) ||
+            complex_number?(argument)
+        end
+
+        def integer?(argument)
+          numeric?(argument) && Integer(argument_value(argument), exception: false)
+        end
+
+        def float?(argument)
+          numeric?(argument) && Float(argument_value(argument), exception: false)
+        end
+
+        # Add correct quotes to the formatted string, preferring retaining the existing
+        # quotes if possible.
+        def quote(string, node)
+          str_node = node.first_argument
+          start_delimiter = str_node.loc.begin.source
+          end_delimiter = str_node.loc.end.source
+
+          # If there is any interpolation, the delimiters need to be changed potentially
+          if node.each_descendant(:dstr, :dsym).any?
+            case start_delimiter
+            when "'"
+              start_delimiter = end_delimiter = '"'
+            when /\A%q(.)/
+              start_delimiter = "%Q#{Regexp.last_match[1]}"
+            end
+          end
+
+          "#{start_delimiter}#{string}#{end_delimiter}"
+        end
+
+        def argument_values(arguments)
+          arguments.map { |argument| argument_value(argument) }
+        end
+
+        def argument_value(argument)
+          argument = argument.children.first if argument.begin_type?
+
+          if argument.dsym_type?
+            dsym_value(argument)
+          elsif argument.hash_type?
+            hash_value(argument)
+          elsif rational_number?(argument)
+            rational_value(argument)
+          elsif complex_number?(argument)
+            complex_value(argument)
+          elsif argument.respond_to?(:value)
+            argument.value
+          else
+            argument.source
+          end
+        end
+
+        def dsym_value(dsym_node)
+          dsym_node.children.first.source
+        end
+
+        def hash_value(hash_node)
+          hash_node.each_pair.with_object({}) do |pair, hash|
+            hash[pair.key.value] = argument_value(pair.value)
+          end
+        end
+
+        def rational_value(rational_node)
+          rational_node.source.to_r
+        end
+
+        def complex_value(complex_node)
+          Complex(complex_node.source)
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Check for uses of `Object#freeze` on immutable objects.
       #
-      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
       #
       # NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated
       # string literals when `# frozen-string-literal: true` is used.
@@ -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)
@@ -60,7 +60,7 @@ module RuboCop
             (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
             (send _ {:count :length :size} ...)
-            (block (send _ {:count :length :size} ...) ...)
+            (any_block (send _ {:count :length :size} ...) ...)
           }
         PATTERN
       end

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

@@ -11,6 +11,9 @@ module RuboCop
       # will not register an offense, because it allows the initializer to take a different
       # number of arguments as its superclass potentially does.
       #
+      # NOTE: If an initializer takes any arguments and has an empty body, RuboCop
+      # assumes it to *not* be redundant. This is to prevent potential `ArgumentError`.
+      #
       # NOTE: If an initializer argument has a default value, RuboCop assumes it
       # to *not* be redundant.
       #
@@ -19,8 +22,10 @@ module RuboCop
       # initializer.
       #
       # @safety
-      #   This cop is unsafe because if subclass overrides `initialize` method with
-      #   a different arity than superclass.
+      #   This cop is unsafe because removing an empty initializer may alter
+      #   the behavior of the code, particularly if the superclass initializer
+      #   raises an exception. In such cases, the empty initializer may act as
+      #   a safeguard to prevent unintended errors from propagating.
       #
       # @example
       #   # bad
@@ -69,6 +74,10 @@ module RuboCop
       #   end
       #
       #   # good (changes the parameter requirements)
+      #   def initialize(_)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
       #   def initialize(*)
       #   end
       #
@@ -111,7 +120,7 @@ module RuboCop
           return if acceptable?(node)
 
           if node.body.nil?
-            register_offense(node, MSG_EMPTY)
+            register_offense(node, MSG_EMPTY) if node.arguments.empty?
           else
             return if node.body.begin_type?
 

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

@@ -69,17 +69,24 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
+        LINE_CONTINUATION = '\\'
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
-          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+          kDEF kDEFINED kFALSE kNIL kSELF kTRUE tAMPER tBANG tCARET tCHARACTER tCOLON3 tCONSTANT
+          tCVAR tDOT2 tDOT3 tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR tLAMBDA tLBRACK tLCURLY
+          tLPAREN_ARG tPIPE tQSYMBOLS_BEG tQWORDS_BEG tREGEXP_BEG tSTAR tSTRING tSTRING_BEG tSYMBEG
+          tSYMBOL tSYMBOLS_BEG tTILDE tUMINUS tUNARY_NUM tUPLUS tWORDS_BEG tXSTRING_BEG
         ].freeze
-        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[tIDENTIFIER kRETURN kBREAK kNEXT kYIELD].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[
+          tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
+        ].freeze
+        ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
 
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
             next if require_line_continuation?(range)
             next unless redundant_line_continuation?(range)
 
@@ -87,20 +94,27 @@ module RuboCop
               corrector.remove_leading(range, 1)
             end
           end
+
+          inspect_end_of_ruby_code_line_continuation
         end
 
         private
 
         def require_line_continuation?(range)
-          !ends_with_backslash_without_comment?(range.source_line) ||
+          !ends_with_uncommented_backslash?(range) ||
             string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(processed_source[range.line]) ||
+            start_with_arithmetic_operator?(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)
-          source_line.gsub(/#.+/, '').end_with?('\\')
+        def ends_with_uncommented_backslash?(range)
+          # A line continuation always needs to be the last character on the line, which
+          # means that it is impossible to have a comment following a continuation.
+          # Therefore, if the line contains a comment, it cannot end with a continuation.
+          return false if processed_source.line_with_comment?(range.line)
+
+          range.source_line.end_with?(LINE_CONTINUATION)
         end
 
         def string_concatenation?(source_line)
@@ -108,10 +122,13 @@ module RuboCop
         end
 
         def inside_string_literal_or_method_with_argument?(range)
+          line_range = range_by_whole_lines(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)
+            inside_string_literal?(range, token) ||
+              method_with_argument?(line_range, token, next_token)
           end
         end
 
@@ -125,8 +142,28 @@ module RuboCop
           return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
-          source = node.parent ? node.parent.source : node.source
-          parse(source.gsub("\\\n", "\n")).valid_syntax?
+          # Check if source is still valid without the continuation
+          source = processed_source.raw_source.dup
+          source[range.begin_pos, range.length] = "\n"
+          parse(source).valid_syntax?
+        end
+
+        def inspect_end_of_ruby_code_line_continuation
+          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          return unless code_ends_with_continuation?(last_line)
+
+          last_column = last_line.length
+          line_continuation_range = range_between(last_column - 1, last_column)
+
+          add_offense(line_continuation_range) do |corrector|
+            corrector.remove_trailing(line_continuation_range, 1)
+          end
+        end
+
+        def code_ends_with_continuation?(last_line)
+          return false if processed_source.line_with_comment?(processed_source.ast.last_line)
+
+          last_line.end_with?(LINE_CONTINUATION)
         end
 
         def inside_string_literal?(range, token)
@@ -137,15 +174,14 @@ module RuboCop
         #
         #   do_something \
         #     argument
-        def method_with_argument?(current_token, next_token)
+        def method_with_argument?(line_range, current_token, next_token)
           return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+          return false unless current_token.pos.overlaps?(line_range)
 
           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?
@@ -158,11 +194,10 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|
-            return node if node.respond_to?(:expression) && node.expression&.last_line == last_line
+            return node if same_line?(node, last_line)
           end
         end
 
@@ -191,8 +226,9 @@ module RuboCop
           node.call_type? && !node.arguments.empty?
         end
 
-        def start_with_arithmetic_operator?(source_line)
-          %r{\A\s*[+\-*/%]}.match?(source_line)
+        def start_with_arithmetic_operator?(range)
+          line_range = processed_source.buffer.line_range(range.line + 1)
+          ARITHMETIC_OPERATOR_TOKENS.include?(processed_source.first_token_of(line_range).type)
         end
       end
     end

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

@@ -13,14 +13,16 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Base
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
         extend AutoCorrector
 
-        ALLOWED_NODE_TYPES = %i[and or send splat kwsplat].freeze
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
 
         # @!method square_brackets?(node)
-        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
+        PATTERN
 
         # @!method method_node_and_args(node)
         def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
@@ -31,9 +33,6 @@ module RuboCop
         # @!method allowed_pin_operator?(node)
         def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
 
-        # @!method arg_in_call_with_block?(node)
-        def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
-
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
@@ -42,6 +41,10 @@ module RuboCop
 
         private
 
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
         def parens_allowed?(node)
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
@@ -53,13 +56,12 @@ 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
 
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
-            allowed_method_call?(node) ||
             allowed_multiple_expression?(node) ||
             allowed_ternary?(node) ||
             node.parent&.range_type?
@@ -70,18 +72,13 @@ module RuboCop
           keyword_ancestor?(node) && parens_required?(node)
         end
 
-        def allowed_method_call?(node)
-          # Don't flag `method (arg) { }`
-          arg_in_call_with_block?(node) && !parentheses?(node.parent)
-        end
-
         def allowed_multiple_expression?(node)
           return false if node.children.one?
 
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -98,17 +95,17 @@ 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?
+            !node.operator_method? && 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?
+          parent.type?(:return, :next, :break)
         end
 
         def empty_parentheses?(node)
@@ -137,6 +134,10 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node)
+              begin_node = begin_node.parent
+            end
+
             return offense(begin_node, message)
           end
 
@@ -146,20 +147,25 @@ module RuboCop
         # 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 literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
+            return 'an assignment'
+          end
           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 'a method argument' if argument_of_parenthesized_method_call?(begin_node)
 
           return if begin_node.chained?
 
-          if node.and_type? || node.or_type?
+          if node.operator_keyword?
             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 !node.and_type? && begin_node.parent&.and_type?
             return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
@@ -174,18 +180,30 @@ module RuboCop
         # @!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']
+        def argument_of_parenthesized_method_call?(begin_node)
+          node = begin_node.children.first
+          return false if node.basic_conditional? || method_call_parentheses_required?(node)
+          return false unless (parent = begin_node.parent)
 
-          !!parentheses_around_condition_config['AllowInMultilineConditions']
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
+        def allow_in_multiline_conditions?
+          !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end
 
         def check_send(begin_node, node)
           return check_unary(begin_node, node) if node.unary_operation?
 
           return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node)
+          return if call_chain_starts_with_int?(begin_node, node) ||
+                    do_end_block_in_method_chain?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
@@ -215,7 +233,13 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
@@ -252,7 +276,7 @@ module RuboCop
         end
 
         def only_begin_arg?(args)
-          args.one? && args.first.begin_type?
+          args.one? && args.first&.begin_type?
         end
 
         def first_argument?(node)
@@ -285,6 +309,12 @@ module RuboCop
           recv&.int_type? && (parent = begin_node.parent) &&
             parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
+
+        def do_end_block_in_method_chain?(begin_node, node)
+          return false unless (block = node.each_descendant(:any_block).first)
+
+          block.keywords? && begin_node.each_ancestor(:call).any?
+        end
       end
     end
   end