rubocop 1.69.2 → 1.72.2

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

@@ -130,7 +130,7 @@ module RuboCop
 
           block_body_node.each_descendant(:next, :break) do |n|
             # Ignore `next`/`break` inside an inner block
-            next if n.each_ancestor(:block).first != block_body_node.parent
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
             next unless n.first_argument
 
             nodes << n.first_argument

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def instance_eval_block?(node)
-          node.block_type? && node.method?(:instance_eval)
+          node.any_block_type? && node.method?(:instance_eval)
         end
 
         def report_on_flow_command?(node)

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

@@ -108,7 +108,7 @@ module RuboCop
         private
 
         def loop_method?(node)
-          return false unless node.block_type? || node.numblock_type?
+          return false unless node.any_block_type?
 
           send_node = node.send_node
           loopable = send_node.enumerable_method? || send_node.enumerator_method? ||

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

@@ -159,12 +159,12 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
+          (any_block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -268,7 +268,7 @@ module RuboCop
         end
 
         def start_of_new_scope?(child)
-          child.module_type? || child.class_type? || child.sclass_type? || eval_call?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
         end
 
         def eval_call?(child)
@@ -282,7 +282,7 @@ module RuboCop
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
+                (any_block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -17,7 +17,7 @@ module RuboCop
       # rescue, ensure, etc.
       #
       # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
-      # operator assignment can cause NameError if this assignment has been used to declare
+      # operator assignment can cause `NameError` if this assignment has been used to declare
       # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
       # "undefined local variable or method `a' for main:Object (NameError)".
       #

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant` or `class << self`. Even if `private` access modifier is used,
+      # it is public scope despite its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     class << self
+      #       private
+      #       PRIVATE_CONST = 42
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        def on_casgn(node)
+          return if node.each_ancestor(:sclass).any?
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+
+          add_offense(node)
+        end
+
+        private
+
+        def after_private_modifier?(left_siblings)
+          access_modifier_candidates = left_siblings.compact.select do |left_sibling|
+            left_sibling.respond_to?(:send_type?) && left_sibling.send_type?
+          end
+
+          access_modifier_candidates.any? do |candidate|
+            candidate.command?(:private) && candidate.arguments.none?
+          end
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -35,7 +35,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(send (send nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
 
         # @!method useless_abbreviated_assignment?(node)
         def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
@@ -50,6 +50,7 @@ module RuboCop
             corrector.replace(node, variable)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
           return unless useless_abbreviated_assignment?(node)

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

@@ -72,7 +72,7 @@ module RuboCop
         def_node_matcher :method_definition, <<~PATTERN
           {
             (def %1 ...)
-            ({block numblock} (send _ :define_method (sym %1)) ...)
+            (any_block (send _ :define_method (sym %1)) ...)
           }
         PATTERN
 
@@ -108,7 +108,7 @@ module RuboCop
 
         def find_method_definition(node, method_name)
           node.each_ancestor.lazy.map do |ancestor|
-            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+            ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
           end.find(&:itself)

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

@@ -103,7 +103,7 @@ module RuboCop
           expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
             check_void_op(expr) do
-              block_node = node.each_ancestor(:block).first
+              block_node = node.each_ancestor(:any_block).first
 
               block_node&.method?(:each)
             end
@@ -113,7 +113,8 @@ module RuboCop
         end
 
         def check_expression(expr)
-          expr = expr.body if expr.if_type? && expr.modifier_form?
+          expr = expr.body if expr.if_type?
+          return unless expr
 
           check_literal(expr)
           check_var(expr)
@@ -178,7 +179,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return if !node.send_type? && !node.block_type? && !node.numblock_type?
+          return unless node.type?(:send, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -200,11 +201,6 @@ module RuboCop
           # NOTE: the `begin` node case is already handled via `on_begin`
           return if body.begin_type?
 
-          check_void_op(body) do
-            block_node = node.each_ancestor(:block).first
-            block_node&.method?(:each)
-          end
-
           check_expression(body)
         end
 
@@ -229,7 +225,7 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
-          return if node.parent.if_type? && node.parent.modifier_form?
+          return if node.parent.if_type?
 
           corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
         end

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

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

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

@@ -52,12 +52,19 @@ module RuboCop
               'Prefer reading the data from an external source.'
         RESTRICT_ON_SEND = [:[]].freeze
 
+        # @!method set_const?(node)
+        def_node_matcher :set_const?, <<~PATTERN
+          (const {cbase nil?} :Set)
+        PATTERN
+
         def on_array(node)
           add_offense(node) if node.children.length >= collection_threshold
         end
         alias on_hash on_array
 
         def on_index(node)
+          return unless set_const?(node.receiver)
+
           add_offense(node) if node.arguments.length >= collection_threshold
         end
 

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

@@ -36,7 +36,7 @@ module RuboCop
         include MethodComplexity
         include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Cyclomatic complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if while until for csend block block_pass
                            rescue when in_pattern and or or_asgn and_asgn].freeze
 

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

@@ -48,7 +48,7 @@ module RuboCop
         LABEL = 'Method'
 
         def on_def(node)
-          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if allowed?(node.method_name)
 
           check_code_length(node)
         end
@@ -57,6 +57,9 @@ module RuboCop
         def on_block(node)
           return unless node.method?(:define_method)
 
+          method_name = node.send_node.first_argument
+          return if method_name.basic_literal? && allowed?(method_name.value)
+
           check_code_length(node)
         end
         alias on_numblock on_block
@@ -66,6 +69,10 @@ module RuboCop
         def cop_label
           LABEL
         end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
       end
     end
   end

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

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

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

@@ -27,7 +27,7 @@ module RuboCop
       #     end                           # ===
       #   end                             # 7 complexity points
       class PerceivedComplexity < CyclomaticComplexity
-        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
         COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
 

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -26,6 +26,13 @@ module RuboCop
           extend NodePattern::Macros
           include RuboCop::AST::Sexp
 
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
           # Plug into the calculator
           def initialize(node, discount_repeated_attributes: false)
             super(node)
@@ -114,13 +121,6 @@ module RuboCop
             calls.fetch(value) { yield [calls, value] }
           end
 
-          VAR_SETTER_TO_GETTER = {
-            lvasgn: :lvar,
-            ivasgn: :ivar,
-            cvasgn: :cvar,
-            gvasgn: :gvar
-          }.freeze
-
           # @returns `[receiver, method | nil]` for the given setter `node`
           # or `nil` if it is not a setter.
           def setter_to_getter(node)

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

@@ -5,10 +5,10 @@ module RuboCop
     # This module checks for nodes that should be aligned to the left or right.
     # This amount is determined by the instance variable @column_delta.
     module Alignment
-      private
-
       SPACE = ' '
 
+      private
+
       attr_reader :column_delta
 
       def configured_indentation_width

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

@@ -18,12 +18,12 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      def ignored_line?
+      def ignored_line?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `ignored_line?` is deprecated. Use `allowed_line?` instead.
         WARNING
 
-        allowed_line?
+        allowed_line?(line)
       end
 
       def matches_allowed_pattern?(line)
@@ -31,12 +31,12 @@ module RuboCop
       end
 
       # @deprecated Use matches_allowed_pattern? instead
-      def matches_ignored_pattern?
+      def matches_ignored_pattern?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
         WARNING
 
-        matches_allowed_pattern?
+        matches_allowed_pattern?(line)
       end
 
       def allowed_patterns

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

@@ -43,14 +43,14 @@ module RuboCop
     # (Note: Passes may not happen exactly in this sequence.)
     module CheckLineBreakable
       def extract_breakable_node(node, max)
-        if node.send_type?
+        if node.call_type?
           return if chained_to_heredoc?(node)
 
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
         elsif node.def_type?
           return extract_breakable_node_from_elements(node, node.arguments, max)
-        elsif node.array_type? || node.hash_type?
+        elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
         end
         nil
@@ -74,9 +74,9 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` node is not parenthesized, don't move the first element, because it
+        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
         # can result in changed behavior or a syntax error.
-        if node.send_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
+        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
           elements = elements.drop(1)
         end
 
@@ -98,10 +98,10 @@ module RuboCop
       end
 
       # @api private
-      # If a send node contains a heredoc argument, splitting cannot happen
+      # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.send_type? || node.array_type?
+        return index unless node.type?(:call, :array)
 
         heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
@@ -154,9 +154,9 @@ module RuboCop
           # Ignore ancestors on different lines.
           break if ancestor.first_line != node.first_line
 
-          if ancestor.hash_type? || ancestor.array_type?
+          if ancestor.type?(:hash, :array)
             elements = ancestor.children
-          elsif ancestor.send_type?
+          elsif ancestor.call_type?
             elements = process_args(ancestor.arguments)
           else
             next
@@ -171,12 +171,12 @@ module RuboCop
       # @api private
       def contained_by_multiline_collection_that_could_be_broken_up?(node)
         node.each_ancestor.find do |ancestor|
-          if (ancestor.hash_type? || ancestor.array_type?) &&
+          if ancestor.type?(:hash, :array) &&
              breakable_collection?(ancestor, ancestor.children)
             return children_could_be_broken_up?(ancestor.children)
           end
 
-          next unless ancestor.send_type?
+          next unless ancestor.call_type?
 
           args = process_args(ancestor.arguments)
           return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
@@ -227,7 +227,7 @@ module RuboCop
 
       def chained_to_heredoc?(node)
         while (node = node.receiver)
-          return true if (node.str_type? || node.dstr_type? || node.xstr_type?) && node.heredoc?
+          return true if node.type?(:str, :dstr, :xstr) && node.heredoc?
         end
 
         false

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

@@ -73,14 +73,16 @@ module RuboCop
             node.else_branch.loc.line
           elsif node.elsif?
             node.each_ancestor(:if).find(&:if?).loc.end.line
+          elsif node.if? && node.parent && parentheses?(node.parent)
+            node.parent.loc.end.line
           end
-        elsif node.block_type? || node.numblock_type?
+        elsif node.any_block_type?
           node.loc.end.line
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node) &&
               next_sibling.source_range
           next_sibling.loc.line
         elsif (parent = node.parent)
-          if parent.loc.respond_to?(:end) && parent.loc.end
+          if parent.loc?(:end)
             parent.loc.end.line
           else
             parent.loc.line

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

@@ -20,7 +20,7 @@ module RuboCop
       private
 
       def dig_chain_enabled?
-        @config.for_cop('Style/DigChain')['Enabled']
+        @config.cop_enabled?('Style/DigChain')
       end
     end
   end

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

@@ -6,7 +6,7 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL = '# frozen_string_literal:'
+      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 

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

@@ -11,6 +11,24 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -86,7 +104,7 @@ module RuboCop
         return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
-        return true unless hash_value.send_type? || hash_value.lvar_type?
+        return true unless hash_value.type?(:send, :lvar)
 
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
@@ -109,7 +127,7 @@ module RuboCop
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
         return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
+        def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
@@ -117,7 +135,7 @@ module RuboCop
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
-        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return unless ancestor.type?(:call, :super, :yield)
         return if brackets?(ancestor)
 
         ancestor
@@ -150,7 +168,7 @@ module RuboCop
         parent = method_dispatch_node.parent
         return false unless parent
 
-        parent.call_type? || parent.super_type? || parent.yield_type?
+        parent.type?(:call, :super, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -212,24 +230,6 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
-
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
-      end
     end
   end
   # rubocop:enable Metrics/ModuleLength