rubocop 1.66.1 → 1.72.2

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

@@ -7,6 +7,8 @@ module RuboCop
         # Style omit_parentheses
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
@@ -30,10 +32,13 @@ module RuboCop
           end
 
           def autocorrect(corrector, node)
+            range = args_begin(node)
             if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
             else
-              corrector.replace(args_begin(node), ' ')
+              corrector.replace(range, ' ')
             end
             corrector.remove(node.loc.end)
           end
@@ -47,11 +52,11 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          def require_parentheses_for_hash_value_omission?(node)
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            node.parent&.conditional? || !last_expression?(node)
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
@@ -106,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
@@ -123,46 +126,48 @@ 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?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
-          def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
               call_in_match_pattern?(node) ||
               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/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
+            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)
@@ -172,6 +177,13 @@ module RuboCop
             end
           end
 
+          def ambiguous_range_argument?(node)
+            return true if (first_arg = node.first_argument)&.range_type? && first_arg.begin.nil?
+            return true if (last_arg = node.last_argument)&.range_type? && last_arg.end.nil?
+
+            false
+          end
+
           def allowed_multiline_call_with_parentheses?(node)
             cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
           end
@@ -190,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)
@@ -198,7 +210,7 @@ module RuboCop
           end
 
           def logical_operator?(node)
-            (node.and_type? || node.or_type?) && node.logical_operator?
+            node.operator_keyword? && node.logical_operator?
           end
 
           def hash_literal?(node)
@@ -211,7 +223,7 @@ module RuboCop
 
           def unary_literal?(node)
             (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent&.unary_operation?)
+              (node.parent&.send_type? && node.parent.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -61,6 +61,8 @@ module RuboCop
       #   https://bugs.ruby-lang.org/issues/18396.
       # - Parentheses are required in anonymous arguments, keyword arguments
       #   and block passing in Ruby 3.2.
+      # - Parentheses are required when the first argument is a beginless range or
+      #   the last argument is an endless range.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #

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

@@ -45,6 +45,7 @@ module RuboCop
           register_offense(node)
         end
         # rubocop:enable Metrics/CyclomaticComplexity
+        alias on_csend on_send
 
         private
 
@@ -71,9 +72,11 @@ module RuboCop
           return false if node.receiver
 
           any_assignment?(node) do |asgn_node|
-            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
-
-            asgn_node.loc.name.source == node.method_name.to_s
+            if asgn_node.masgn_type?
+              variable_in_mass_assignment?(node.method_name, asgn_node)
+            else
+              asgn_node.loc.name.source == node.method_name.to_s
+            end
           end
         end
 
@@ -98,20 +101,14 @@ module RuboCop
             # `obj.method ||= value` parses as (or-asgn (send ...) ...)
             # which IS an `asgn_node`. Similarly, `obj.method += value` parses
             # as (op-asgn (send ...) ...), which is also an `asgn_node`.
-            if asgn_node.shorthand_asgn?
-              asgn_node, _value = *asgn_node
-              next if asgn_node.send_type?
-            end
+            next if asgn_node.shorthand_asgn? && asgn_node.lhs.call_type?
 
             yield asgn_node
           end
         end
 
         def variable_in_mass_assignment?(variable_name, node)
-          mlhs_node, _mrhs_node = *node
-          var_nodes = *mlhs_node
-
-          var_nodes.any? { |n| n.to_a.first == variable_name }
+          node.assignments.reject(&:send_type?).any? { |n| n.name == variable_name }
         end
 
         def offense_range(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/missing_else.rb

@@ -144,6 +144,8 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
+          node = node.ancestors.find { |ancestor| ancestor.loc.end } unless node.loc.end
+
           case empty_else_style
           when :empty
             corrector.insert_before(node.loc.end, 'else; nil; ')

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

@@ -6,19 +6,49 @@ module RuboCop
       # Checks for the presence of `method_missing` without also
       # defining `respond_to_missing?`.
       #
+      # Not defining `respond_to_missing?` will cause metaprogramming
+      # methods like `respond_to?` to behave unexpectedly:
+      #
+      # [source,ruby]
+      # ----
+      # class StringDelegator
+      #   def initialize(string)
+      #     @string = string
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     @string.send(name, *args)
+      #   end
+      # end
+      #
+      # delegator = StringDelegator.new("foo")
+      # # Claims to not respond to `upcase`.
+      # delegator.respond_to?(:upcase) # => false
+      # # But you can call it.
+      # delegator.upcase # => FOO
+      # ----
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       #   # good
       #   def respond_to_missing?(name, include_private)
-      #     # ...
+      #     @delegate.respond_to?(name) || super
       #   end
       #
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       class MissingRespondToMissing < Base

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/multiline_memoization.rb

@@ -39,11 +39,11 @@ module RuboCop
         BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
-          _lhs, rhs = *node
+          rhs = node.expression
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else

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

@@ -55,68 +55,66 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
-        def on_new_investigation
-          reset_comparison
-        end
+        # @!method simple_double_comparison?(node)
+        def_node_matcher :simple_double_comparison?, <<~PATTERN
+          (send lvar :== lvar)
+        PATTERN
+
+        # @!method simple_comparison_lhs(node)
+        def_node_matcher :simple_comparison_lhs, <<~PATTERN
+          (send ${lvar call} :== $_)
+        PATTERN
+
+        # @!method simple_comparison_rhs(node)
+        def_node_matcher :simple_comparison_rhs, <<~PATTERN
+          (send $_ :== ${lvar call})
+        PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
-
           return unless node == root_of_or_node
-          return unless nested_variable_comparison?(root_of_or_node)
-          return if @allowed_method_comparison
-          return if @compared_elements.size < comparisons_threshold
+          return unless nested_comparison?(node)
 
-          add_offense(node) do |corrector|
-            elements = @compared_elements.join(', ')
-            prefer_method = "[#{elements}].include?(#{variables_in_node(node).first})"
+          return unless (variable, values = find_offending_var(node))
+          return if values.size < comparisons_threshold
 
-            corrector.replace(node, prefer_method)
+          range = offense_range(values)
 
-            reset_comparison
+          add_offense(range) do |corrector|
+            elements = values.map(&:source).join(', ')
+            argument = variable.lvar_type? ? variable_name(variable) : variable.source
+            prefer_method = "[#{elements}].include?(#{argument})"
+
+            corrector.replace(range, prefer_method)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # @!method simple_double_comparison?(node)
-        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-
-        # @!method simple_comparison_lhs?(node)
-        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
-          (send $lvar :== $_)
-        PATTERN
-
-        # @!method simple_comparison_rhs?(node)
-        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
-          (send $_ :== $lvar)
-        PATTERN
-
-        def nested_variable_comparison?(node)
-          return false unless nested_comparison?(node)
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offending_var(node, variables = Set.new, values = [])
+          if node.or_type?
+            find_offending_var(node.lhs, variables, values)
+            find_offending_var(node.rhs, variables, values)
+          elsif simple_double_comparison?(node)
+            return
+          elsif (var, obj = simple_comparison(node))
+            return if allow_method_comparison? && obj.call_type?
 
-          variables_in_node(node).count == 1
-        end
+            variables << var
+            return if variables.size > 1
 
-        def variables_in_node(node)
-          if node.or_type?
-            node.node_parts.flat_map { |node_part| variables_in_node(node_part) }.uniq
-          else
-            variables_in_simple_node(node)
+            values << obj
           end
-        end
 
-        def variables_in_simple_node(node)
-          simple_double_comparison?(node) do |var1, var2|
-            return [variable_name(var1), variable_name(var2)]
-          end
-          if (var, obj = simple_comparison_lhs?(node)) || (obj, var = simple_comparison_rhs?(node))
-            @allowed_method_comparison = true if allow_method_comparison? && obj.send_type?
-            @compared_elements << obj.source
-            return [variable_name(var)]
-          end
+          [variables.first, values] if variables.any?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-          []
+        def offense_range(values)
+          values.first.parent.source_range.begin.join(values.last.parent.source_range.end)
         end
 
         def variable_name(node)
@@ -132,7 +130,15 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison_lhs?(node) || simple_comparison_rhs?(node) || nested_comparison?(node)
+          !!simple_comparison(node) || nested_comparison?(node)
+        end
+
+        def simple_comparison(node)
+          if (var, obj = simple_comparison_lhs(node)) || (obj, var = simple_comparison_rhs(node))
+            return if var.call_type? && !allow_method_comparison?
+
+            [var, obj]
+          end
         end
 
         def root_of_or_node(or_node)
@@ -145,11 +151,6 @@ module RuboCop
           end
         end
 
-        def reset_comparison
-          @compared_elements = []
-          @allowed_method_comparison = false
-        end
-
         def allow_method_comparison?
           cop_config.fetch('AllowMethodComparison', true)
         end

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

@@ -19,7 +19,7 @@ module RuboCop
       # acceptable value other than none, it will suppress the offenses
       # raised by this cop. It enforces frozen state.
       #
-      # 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, interpolated strings are not frozen when
       # `# frozen-string-literal: true` is used, so this cop enforces explicit
@@ -125,15 +125,14 @@ module RuboCop
         MSG = 'Freeze mutable objects assigned to constants.'
 
         def on_casgn(node)
-          _scope, _const_name, value = *node
-          if value.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
-            value = parent.children.last
+            on_assignment(parent.children.last)
+          else
+            on_assignment(node.expression)
           end
-
-          on_assignment(value)
         end
 
         private
@@ -198,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)
@@ -239,7 +238,7 @@ module RuboCop
 
         # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
-          (begin ({irange erange} _ _))
+          (begin (range _ _))
         PATTERN
       end
     end

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

@@ -46,10 +46,12 @@ module RuboCop
           @corrected_nodes = nil
         end
 
+        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
           return if double_negation?(condition) || !negated_condition?(condition)
+          return unless condition.arguments.size < 2
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
@@ -62,6 +64,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 
@@ -71,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
@@ -92,13 +95,12 @@ module RuboCop
         end
 
         def correct_negated_condition(corrector, node)
-          receiver, method_name, rhs = *node
           replacement =
             if node.negation_method?
-              receiver.source
+              node.receiver.source
             else
-              inverted_method = method_name.to_s.sub('!', '=')
-              "#{receiver.source} #{inverted_method} #{rhs.source}"
+              inverted_method = node.method_name.to_s.sub('!', '=')
+              "#{node.receiver.source} #{inverted_method} #{node.first_argument.source}"
             end
 
           corrector.replace(node, replacement)

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def modifier?(node)
-          node&.basic_conditional? && node&.modifier_form?
+          node&.basic_conditional? && node.modifier_form?
         end
 
         def autocorrect(corrector, node)

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

@@ -35,11 +35,11 @@ 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)
-            add_offense(nested.source_range, message: message) do |corrector|
+            add_offense(nested, message: message) do |corrector|
               autocorrect(corrector, nested)
             end
           end

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

@@ -18,7 +18,6 @@ module RuboCop
       class NestedTernaryOperator < Base
         extend AutoCorrector
         include RangeHelp
-        include IgnoredNode
 
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` constructs instead.'
 
@@ -45,9 +44,11 @@ module RuboCop
         end
 
         def remove_parentheses(source)
-          return source unless source.start_with?('(')
-
-          source.delete_prefix('(').delete_suffix(')')
+          if source.start_with?('(') && source.end_with?(')')
+            source.delete_prefix('(').delete_suffix(')')
+          else
+            source
+          end
         end
 
         def replace_loc_and_whitespace(corrector, range, replacement)

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def requires_parens?(child)
-          child.and_type? || child.or_type? ||
+          child.operator_keyword? ||
             (child.send_type? && child.binary_operation?) ||
             (child.if_type? && child.ternary?)
         end

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

@@ -30,11 +30,13 @@ module RuboCop
         minimum_target_ruby_version 2.6
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[then yield_self].freeze
 
         def on_block(node)
+          return unless RESTRICT_ON_SEND.include?(node.method_name)
+
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
 
         def on_send(node)
@@ -42,29 +44,26 @@ module RuboCop
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 
         def check_method_node(node)
-          return unless preferred_method?(node)
-
-          message = message(node)
-          add_offense(node.loc.selector, message: message) do |corrector|
-            prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+          if preferred_method?(node)
+            correct_style_detected
+          else
+            opposite_style_detected
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              prefer = style == :then && node.receiver.nil? ? 'self.then' : style
 
-            corrector.replace(node.loc.selector, prefer)
+              corrector.replace(node.loc.selector, prefer)
+            end
           end
         end
 
         def preferred_method?(node)
-          case style
-          when :then
-            node.method?(:yield_self)
-          when :yield_self
-            node.method?(:then)
-          else
-            false
-          end
+          node.method?(style)
         end
 
         def message(node)