rubocop 1.66.0 → 1.67.0

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

@@ -68,6 +68,8 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
       #
       #   end
       #
@@ -76,6 +78,8 @@ module RuboCop
       #   class Foo
       #
       #     private :bar, :baz
+      #     private *%i[qux quux]
+      #     private *METHOD_NAMES
       #
       #   end
       #
@@ -128,7 +132,9 @@ module RuboCop
 
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
-          (send nil? {:private :protected :public :module_function} (sym _))
+          (send nil? {:private :protected :public :module_function}
+            {(sym _) (splat {#percent_symbol_array? const})}
+          )
         PATTERN
 
         # @!method access_modifier_with_attr?(node)
@@ -170,6 +176,10 @@ module RuboCop
           end
         end
 
+        def percent_symbol_array?(node)
+          node.array_type? && node.percent_literal?(:symbol)
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
@@ -218,7 +228,7 @@ module RuboCop
 
         def find_corresponding_def_node(node)
           if access_modifier_with_symbol?(node)
-            method_name = node.first_argument.value
+            method_name = node.first_argument.respond_to?(:value) && node.first_argument.value
             node.parent.each_child_node(:def).find do |child|
               child.method?(method_name)
             end

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

@@ -10,6 +10,9 @@ module RuboCop
       # NOTE: If there is a method call before the accessor method it is always allowed
       # as it might be intended like Sorbet.
       #
+      # NOTE: If there is a RBS::Inline annotation comment just after the accessor method
+      # it is always allowed.
+      #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo
@@ -92,7 +95,7 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def groupable_accessor?(node)
           return true unless (previous_expression = node.left_siblings.last)
 
@@ -105,11 +108,16 @@ module RuboCop
 
           return true unless previous_expression.send_type?
 
+          # Accessors with RBS::Inline annotations shouldn't be groupable.
+          return false if processed_source.comments.any? do |c|
+            same_line?(c, previous_expression) && c.text.start_with?('#:')
+          end
+
           previous_expression.attribute_accessor? ||
             previous_expression.access_modifier? ||
             node.first_line - previous_expression.last_line > 1 # there is a space between nodes
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def class_send_elements(class_node)
           class_def = class_node.body

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

@@ -180,7 +180,8 @@ module RuboCop
         end
 
         def only_forwards_all?(send_classifications)
-          send_classifications.all? { |_, c, _, _| c == :all }
+          all_classifications = %i[all all_anonymous].freeze
+          send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -188,8 +189,8 @@ module RuboCop
           _rest_arg, _kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if !forward_rest && !forward_kwrest
+          send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            if !forward_rest && !forward_kwrest && c != :all_anonymous
               # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
               # in Ruby 3.3.0.
               if outside_block?(forward_block_arg)
@@ -213,6 +214,7 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
+          return if send_inside_block?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
@@ -355,8 +357,15 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
+        def send_inside_block?(send_classifications)
+          send_classifications.any? do |send_node, *|
+            send_node.each_ancestor(:block, :numblock).any?
+          end
+        end
+
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
+          return if node.send_type? && node.method?(:[])
 
           add_parentheses(node, corrector)
         end
@@ -374,6 +383,23 @@ module RuboCop
           # @!method forwarded_block_arg?(node, block_name)
           def_node_matcher :forwarded_block_arg?, '(block_pass {(lvar %1) nil?})'
 
+          # @!method def_all_anonymous_args?(node)
+          def_node_matcher :def_all_anonymous_args?, <<~PATTERN
+            (
+              def _
+              (args ... (restarg) (kwrestarg) (blockarg nil?))
+              _
+            )
+          PATTERN
+
+          # @!method send_all_anonymous_args?(node)
+          def_node_matcher :send_all_anonymous_args?, <<~PATTERN
+            (
+              send _ _
+              ... (forwarded_restarg) (hash (forwarded_kwrestarg)) (block_pass nil?)
+            )
+          PATTERN
+
           def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config)
             @def_node = def_node
             @send_node = send_node
@@ -405,7 +431,9 @@ module RuboCop
           def classification
             return nil unless forwarded_rest_arg || forwarded_kwrest_arg || forwarded_block_arg
 
-            if can_forward_all?
+            if ruby_32_only_anonymous_forwarding?
+              :all_anonymous
+            elsif can_forward_all?
               :all
             else
               :rest_or_kwrest
@@ -414,16 +442,28 @@ module RuboCop
 
           private
 
+          # rubocop:disable Metrics/CyclomaticComplexity
           def can_forward_all?
             return false if any_arg_referenced?
-            return false if ruby_32_missing_rest_or_kwest?
+            return false if ruby_30_or_lower_optarg?
+            return false if ruby_32_or_higher_missing_rest_or_kwest?
             return false unless offensive_block_forwarding?
             return false if additional_kwargs_or_forwarded_kwargs?
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
+          # rubocop:enable Metrics/CyclomaticComplexity
+
+          # def foo(a = 41, ...) is a syntax error in 3.0.
+          def ruby_30_or_lower_optarg?
+            target_ruby_version <= 3.0 && @def_node.arguments.any?(&:optarg_type?)
+          end
+
+          def ruby_32_only_anonymous_forwarding?
+            def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
+          end
 
-          def ruby_32_missing_rest_or_kwest?
+          def ruby_32_or_higher_missing_rest_or_kwest?
             target_ruby_version >= 3.2 && !forwarded_rest_and_kwrest_args
           end
 

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

@@ -176,6 +176,10 @@ module RuboCop
 
         BRACES_REQUIRED_MESSAGE = "Brace delimiters `{...}` required for '%<method_name>s' method."
 
+        def self.autocorrect_incompatible_with
+          [Style::RedundantBegin]
+        end
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
@@ -341,8 +345,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node)
+          return true if require_braces?(node) || require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -352,6 +357,7 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_braces?(node)
           return false unless node.braces?
@@ -361,6 +367,13 @@ module RuboCop
           end
         end
 
+        def require_do_end?(node)
+          return false if node.braces? || node.multiline?
+          return false unless (resbody = node.each_descendant(:resbody).first)
+
+          resbody.children.first&.array_type?
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||

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

@@ -21,6 +21,7 @@ module RuboCop
       #   array.reject(&:nil?)
       #   array.reject { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.filter { |e| !e.nil? }
       #   array.grep_v(nil)
       #   array.grep_v(NilClass)
       #
@@ -29,10 +30,9 @@ module RuboCop
       #
       #   # bad
       #   hash.reject!(&:nil?)
-      #   array.delete_if(&:nil?)
       #   hash.reject! { |k, v| v.nil? }
-      #   array.delete_if { |e| e.nil? }
       #   hash.select! { |k, v| !v.nil? }
+      #   hash.filter! { |k, v| !v.nil? }
       #
       #   # good
       #   hash.compact!
@@ -48,14 +48,15 @@ module RuboCop
         extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject! select select! grep_v].freeze
+        RESTRICT_ON_SEND = %i[reject reject! select select! filter filter! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
+        FILTER_METHODS = %i[filter filter!].freeze
 
         minimum_target_ruby_version 2.4
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
-          (call !nil? {:reject :delete_if :reject!}
+          (call !nil? {:reject :reject!}
             (block_pass
               (sym :nil?)))
         PATTERN
@@ -64,7 +65,7 @@ module RuboCop
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (call
-              !nil? {:reject :delete_if :reject!})
+              !nil? {:reject :reject!})
             $(args ...)
             (call
               $(lvar _) :nil?))
@@ -74,7 +75,7 @@ module RuboCop
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (call
-              !nil? {:select :select!})
+              !nil? {:select :select! :filter :filter!})
             $(args ...)
             (call
               (call
@@ -87,11 +88,10 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if target_ruby_version < 2.6 && FILTER_METHODS.include?(node.method_name)
           return unless (range = offense_range(node))
           return if allowed_receiver?(node.receiver)
-          if (target_ruby_version <= 3.0 || node.method?(:delete_if)) && to_enum_method?(node)
-            return
-          end
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def good_method_name(node)
-          if node.bang_method? || node.method?(:delete_if)
+          if node.bang_method?
             'compact!'
           else
             'compact'

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

@@ -7,6 +7,9 @@ module RuboCop
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
+      # NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+      # as it is impossible to determine which variable name should be prioritized.
+      #
       # @safety
       #   The cop is unsafe, because the first loop might modify state that the
       #   second loop depends on; these two aren't combinable.
@@ -61,6 +64,7 @@ module RuboCop
 
         MSG = 'Combine this loop with the previous loop.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
@@ -68,9 +72,12 @@ module RuboCop
           return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            next unless node.arguments == node.left_sibling.arguments
+
             combine_with_left_sibling(corrector, node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
 

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

@@ -10,7 +10,7 @@ module RuboCop
       #
       # Note that some comments
       # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # are allowed.
+      # and RBS::Inline annotation comments are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -82,6 +82,8 @@ module RuboCop
 
         def offensive?(comment)
           line = source_line(comment)
+          return false if rbs_inline_annotation?(line, comment)
+
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
@@ -89,6 +91,10 @@ module RuboCop
         def source_line(comment)
           comment.source_range.source_line
         end
+
+        def rbs_inline_annotation?(line, comment)
+          comment.text.start_with?('#:') && line.start_with?(/\A\s*def\s/)
+        end
       end
     end
   end

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

@@ -73,7 +73,7 @@ module RuboCop
           elsif_branches << node.if_branch
 
           else_branch = node.else_branch
-          if else_branch&.if_type? && else_branch&.elsif?
+          if else_branch&.if_type? && else_branch.elsif?
             expand_elsif(else_branch, elsif_branches)
           else
             elsif_branches << else_branch

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

@@ -36,7 +36,7 @@ module RuboCop
         def on_class(node)
           return unless data_define?(node.parent_class)
 
-          add_offense(node.parent_class.source_range) do |corrector|
+          add_offense(node.parent_class) do |corrector|
             corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 

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

@@ -179,6 +179,7 @@ module RuboCop
 
         def comment_in_else?(node)
           node = node.parent while node.if_type? && node.elsif?
+          return false unless node.else?
 
           processed_source.contains_comment?(node.loc.else.join(node.source_range.end))
         end

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

@@ -34,7 +34,7 @@ module RuboCop
         def_node_matcher :array_node, '(send (const {nil? cbase} :Array) :new (array)?)'
 
         # @!method hash_node(node)
-        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new (array)?)'
+        def_node_matcher :hash_node, '(send (const {nil? cbase} :Hash) :new)'
 
         # @!method str_node(node)
         def_node_matcher :str_node, '(send (const {nil? cbase} :String) :new)'

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

@@ -136,7 +136,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.source_range, message: message) do |corrector|
+          add_offense(line_node, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end

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

@@ -234,11 +234,11 @@ module RuboCop
         end
 
         def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
           remove_whole_lines(corrector, leave_branch.source_range)
           remove_whole_lines(corrector, node.loc.else)
-          remove_whole_lines(corrector, node.loc.end)
           remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
           corrector.insert_after(
             heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"

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

@@ -57,6 +57,11 @@ module RuboCop
           (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
         PATTERN
 
+        # @!method hash_mutated?(node, receiver)
+        def_node_matcher :hash_mutated?, <<~PATTERN
+          `(send %1 :[]= ...)
+        PATTERN
+
         def on_block(node)
           return unless handleable?(node)
 
@@ -103,6 +108,7 @@ module RuboCop
         def handleable?(node)
           return false if use_array_converter_method_as_preceding?(node)
           return false unless (root_receiver = root_receiver(node))
+          return false if hash_mutated?(node, root_receiver)
 
           !root_receiver.literal? || root_receiver.hash_type?
         end

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

@@ -68,7 +68,7 @@ module RuboCop
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
       #
-      # @example EnforcedShorthandSyntax: always (default)
+      # @example EnforcedShorthandSyntax: always
       #
       #   # bad
       #   {foo: foo, bar: bar}
@@ -84,7 +84,7 @@ module RuboCop
       #   # good
       #   {foo: foo, bar: bar}
       #
-      # @example EnforcedShorthandSyntax: either
+      # @example EnforcedShorthandSyntax: either (default)
       #
       #   # good
       #   {foo: foo, bar: bar}

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

@@ -71,7 +71,7 @@ module RuboCop
 
           else_branch = node.else_branch
 
-          return unless else_branch&.if_type? && else_branch&.if?
+          return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|

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

@@ -36,10 +36,12 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def message(node)
           template = if node.if_branch&.begin_type?
                        MSG_NEWLINE
-                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type?
+                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
+                           use_block_in_branches?(node)
                        MSG_IF_ELSE
                      else
                        MSG_TERNARY
@@ -47,15 +49,20 @@ module RuboCop
 
           format(template, expr: node.condition.source)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def autocorrect(corrector, node)
-          if node.if_branch&.begin_type? || node.else_branch&.begin_type?
+          if node.branches.compact.any?(&:begin_type?) || use_block_in_branches?(node)
             corrector.replace(node.loc.begin, "\n")
           else
             corrector.replace(node, replacement(node))
           end
         end
 
+        def use_block_in_branches?(node)
+          node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
+        end
+
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
@@ -74,16 +81,14 @@ module RuboCop
           RUBY
         end
 
-        # rubocop:disable Metrics/AbcSize
         def build_expression(expr)
-          return expr.source if !expr.call_type? || expr.parenthesized? || expr.arguments.empty?
+          return expr.source unless require_argument_parentheses?(expr)
 
           method = expr.source_range.begin.join(expr.loc.selector.end)
           arguments = expr.first_argument.source_range.begin.join(expr.source_range.end)
 
           "#{method.source}(#{arguments.source})"
         end
-        # rubocop:enable Metrics/AbcSize
 
         def build_else_branch(second_condition)
           result = <<~RUBY
@@ -104,6 +109,12 @@ module RuboCop
 
           result
         end
+
+        def require_argument_parentheses?(node)
+          return false unless node.call_type?
+
+          !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
+        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+          add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
             else

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

@@ -105,26 +105,21 @@ module RuboCop
 
         # Value object to extract source ranges for the different parts of a magic comment
         class CommentRange
+          extend SimpleForwardable
+
           DIRECTIVE_REGEXP = Regexp.union(MagicComment::KEYWORDS.map do |_, v|
             Regexp.new(v, Regexp::IGNORECASE)
           end).freeze
 
           VALUE_REGEXP = Regexp.new("(?:#{DIRECTIVE_REGEXP}:\s*)(.*?)(?=;|$)")
 
+          def_delegators :@comment, :text, :loc
           attr_reader :comment
 
           def initialize(comment)
             @comment = comment
           end
 
-          def text
-            @comment.text
-          end
-
-          def loc
-            @comment.loc
-          end
-
           # A magic comment can contain one directive (normal style) or
           # multiple directives (emacs style)
           def directives