rubocop 1.69.2 → 1.71.1

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

@@ -55,6 +55,22 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
+        # @!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
@@ -67,27 +83,16 @@ module RuboCop
 
           add_offense(range) do |corrector|
             elements = values.map(&:source).join(', ')
-            prefer_method = "[#{elements}].include?(#{variable_name(variable)})"
+            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
-
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
@@ -95,8 +100,8 @@ module RuboCop
             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.send_type?
+          elsif (var, obj = simple_comparison(node))
+            return if allow_method_comparison? && obj.call_type?
 
             variables << var
             return if variables.size > 1
@@ -125,12 +130,13 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(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))
+        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

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

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

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

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

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

@@ -33,9 +33,10 @@ module RuboCop
         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)
@@ -43,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)

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Flags uses of OpenStruct, as it is now officially discouraged
+      # Flags uses of `OpenStruct`, as it is now officially discouraged
       # to be used for performance, version compatibility, and potential security issues.
       #
       # @safety
-      #
       #   Note that this cop may flag false positives; for instance, the following legal
       #   use of a hand-rolled `OpenStruct` type would be considered an offense:
       #
-      #   ```
+      #   [source,ruby]
+      #   -----
       #   module MyNamespace
       #     class OpenStruct # not the OpenStruct we're looking for
       #     end
@@ -20,7 +20,7 @@ module RuboCop
       #       OpenStruct.new # resolves to MyNamespace::OpenStruct
       #     end
       #   end
-      #   ```
+      #   -----
       #
       # @example
       #
@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+          parent.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

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

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

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

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

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

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

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

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

@@ -98,7 +98,7 @@ module RuboCop
 
         def style
           return super unless super == :same_as_string_literals
-          return :single_quotes unless string_literals_config['Enabled']
+          return :single_quotes unless config.cop_enabled?('Style/StringLiterals')
 
           string_literals_config['EnforcedStyle'].to_sym
         end

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

@@ -14,7 +14,7 @@ module RuboCop
       # passed multiple arguments.
       #
       # The exploded style has an `AllowedCompactTypes` configuration
-      # option that takes an Array of exception name Strings.
+      # option that takes an `Array` of exception name Strings.
       #
       # @safety
       #   This cop is unsafe because `raise Foo` calls `Foo.exception`, not `Foo.new`.
@@ -50,6 +50,9 @@ module RuboCop
 
         EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
+        ACCEPTABLE_ARG_TYPES = %i[
+          hash forwarded_restarg splat forwarded_restarg forwarded_args
+        ].freeze
 
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
@@ -138,9 +141,8 @@ module RuboCop
 
           arg = args.first
 
-          # Allow code like `raise Ex.new(kw: arg)`.
-          # Allow code like `raise Ex.new(*args)`.
-          arg.hash_type? || arg.splat_type?
+          # Allow nodes that may forward more than one argument
+          ACCEPTABLE_ARG_TYPES.include?(arg.type)
         end
 
         def allowed_non_exploded_type?(arg)

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

@@ -36,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)}))
+              {int (range int int)}))
         PATTERN
 
         # @!method rand_op_integer?(node)
@@ -45,7 +45,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)})
+              {int (range int int)})
             {:+ :-}
             int)
         PATTERN
@@ -56,7 +56,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)})
+              {int (range int int)})
             {:succ :pred :next})
         PATTERN
 

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

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

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

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

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses a redundant current directory in path.
+      # Checks for paths given to `require_relative` that start with
+      # the current directory (`./`), which can be omitted.
       #
       # @example
       #

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

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

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

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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for RuntimeError as the argument of raise/fail.
+      # Checks for `RuntimeError` as the argument of `raise`/`fail`.
       #
       # @example
       #   # bad
@@ -51,7 +51,7 @@ module RuboCop
         end
 
         def string_message?(message)
-          message.str_type? || message.dstr_type? || message.xstr_type?
+          message.type?(:str, :dstr, :xstr)
         end
 
         def fix_compact(node)

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

@@ -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)

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?