rubocop 1.69.0 → 1.76.1

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

@@ -112,6 +112,26 @@ module RuboCop
       #     private attr :quux
       #
       #   end
+      #
+      # @example AllowModifiersOnAliasMethod: true (default)
+      #   # good
+      #   class Foo
+      #
+      #     public alias_method :bar, :foo
+      #     protected alias_method :baz, :foo
+      #     private alias_method :qux, :foo
+      #
+      #   end
+      #
+      # @example AllowModifiersOnAliasMethod: false
+      #   # bad
+      #   class Foo
+      #
+      #     public alias_method :bar, :foo
+      #     protected alias_method :baz, :foo
+      #     private alias_method :qux, :foo
+      #
+      #   end
       class AccessModifierDeclarations < Base
         extend AutoCorrector
 
@@ -130,8 +150,6 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[private protected public module_function].freeze
 
-        ALLOWED_NODE_TYPES = %i[pair block].freeze
-
         # @!method access_modifier_with_symbol?(node)
         def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
           (send nil? {:private :protected :public :module_function}
@@ -145,6 +163,12 @@ module RuboCop
             (send nil? {:attr :attr_reader :attr_writer :attr_accessor} _+))
         PATTERN
 
+        # @!method access_modifier_with_alias_method?, <<~PATTERN
+        def_node_matcher :access_modifier_with_alias_method?, <<~PATTERN
+          (send nil? {:private :protected :public :module_function}
+            (send nil? :alias_method _ _))
+        PATTERN
+
         def on_send(node)
           return if allowed?(node)
 
@@ -162,23 +186,36 @@ module RuboCop
 
         def allowed?(node)
           !node.access_modifier? ||
-            ALLOWED_NODE_TYPES.include?(node.parent&.type) ||
+            node.parent&.type?(:pair, :any_block) ||
             allow_modifiers_on_symbols?(node) ||
-            allow_modifiers_on_attrs?(node)
+            allow_modifiers_on_attrs?(node) ||
+            allow_modifiers_on_alias_method?(node)
         end
 
         def autocorrect(corrector, node)
           case style
           when :group
-            def_nodes = find_corresponding_def_nodes(node)
-            return unless def_nodes.any?
-
-            replace_defs(corrector, node, def_nodes)
+            autocorrect_group_style(corrector, node)
           when :inline
+            autocorrect_inline_style(corrector, node)
+          end
+        end
+
+        def autocorrect_group_style(corrector, node)
+          def_nodes = find_corresponding_def_nodes(node)
+          return unless def_nodes.any?
+
+          replace_defs(corrector, node, def_nodes)
+        end
+
+        def autocorrect_inline_style(corrector, node)
+          if node.parent&.begin_type?
+            remove_modifier_node_within_begin(corrector, node, node.parent)
+          else
             remove_nodes(corrector, node)
-            select_grouped_def_nodes(node).each do |grouped_def_node|
-              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
-            end
+          end
+          select_grouped_def_nodes(node).each do |grouped_def_node|
+            insert_inline_modifier(corrector, grouped_def_node, node.method_name)
           end
         end
 
@@ -194,10 +231,18 @@ module RuboCop
           cop_config['AllowModifiersOnAttrs'] && access_modifier_with_attr?(node)
         end
 
+        def allow_modifiers_on_alias_method?(node)
+          cop_config['AllowModifiersOnAliasMethod'] && access_modifier_with_alias_method?(node)
+        end
+
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node) &&
-            !right_siblings_same_inline_method?(node)) ||
-            (inline_style? && access_modifier_is_not_inlined?(node))
+          if group_style?
+            return false if node.parent ? node.parent.if_type? : access_modifier_with_symbol?(node)
+
+            access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
+          else
+            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+          end
         end
 
         def correctable_group_offense?(node)
@@ -281,7 +326,7 @@ module RuboCop
           argument_less_modifier_node = find_argument_less_modifier_node(node)
           if argument_less_modifier_node
             corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
-          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+          elsif (ancestor = node.each_ancestor(:class, :module).first)
 
             corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else
@@ -302,6 +347,12 @@ module RuboCop
           end
         end
 
+        def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
+          def_node = begin_node.children[1]
+          range = modifier_node.source_range.begin.join(def_node.source_range.begin)
+          corrector.remove(range)
+        end
+
         def def_source(node, def_nodes)
           [
             *processed_source.ast_with_comments[node].map(&:text),

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

@@ -139,12 +139,16 @@ module RuboCop
           style == :separated
         end
 
+        def groupable_sibling_accessor?(node, sibling)
+          sibling.attribute_accessor? &&
+            sibling.method?(node.method_name) &&
+            node_visibility(sibling) == node_visibility(node) &&
+            groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+        end
+
         def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            sibling.attribute_accessor? &&
-              sibling.method?(send_node.method_name) &&
-              node_visibility(sibling) == node_visibility(send_node) &&
-              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
+            groupable_sibling_accessor?(send_node, sibling)
           end
         end
 
@@ -155,13 +159,23 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
+            return if skip_for_grouping?(node)
+
             accessors = groupable_sibling_accessors(node)
-            group_accessors(node, accessors) if node.loc == accessors.first.loc
+            if node.loc == accessors.first.loc || skip_for_grouping?(accessors.first)
+              group_accessors(node, accessors)
+            end
           else
             separate_accessors(node)
           end
         end
 
+        # Group after constants
+        def skip_for_grouping?(node)
+          node.right_siblings.any?(&:casgn_type?) &&
+            node.right_siblings.any? { |n| n.send_type? && groupable_sibling_accessor?(node, n) }
+        end
+
         def group_accessors(node, accessors)
           accessor_names = accessors.flat_map { |accessor| accessor.arguments.map(&:source) }.uniq
 

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

@@ -127,7 +127,7 @@ module RuboCop
         end
 
         def correct_other(node, corrector)
-          return if node.source_range.begin.is?('(')
+          return if node.parenthesized_call?
 
           corrector.wrap(node, '(', ')')
         end

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

@@ -16,21 +16,35 @@ module RuboCop
       #
       # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
       #
-      # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
-      # replaced by `use_args(*)`/`use_kwargs(**)`; if desired, this functionality can be disabled
-      # by setting `UseAnonymousForwarding: false`.
+      # This cop also identifies places where `+use_args(*args)+`/`+use_kwargs(**kwargs)+` can be
+      # replaced by `+use_args(*)+`/`+use_kwargs(**)+`; if desired, this functionality can be
+      # disabled by setting `UseAnonymousForwarding: false`.
       #
       # And this cop has `RedundantRestArgumentNames`, `RedundantKeywordRestArgumentNames`,
       # and `RedundantBlockArgumentNames` options. This configuration is a list of redundant names
       # that are sufficient for anonymizing meaningless naming.
       #
       # Meaningless names that are commonly used can be anonymized by default:
-      # e.g., `*args`, `**options`, `&block`, and so on.
+      # e.g., `+*args+`, `+**options+`, `&block`, and so on.
       #
       # Names not on this list are likely to be meaningful and are allowed by default.
       #
       # This cop handles not only method forwarding but also forwarding to `super`.
       #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -132,7 +146,7 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
-        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
+        ADDITIONAL_ARG_TYPES = %i[lvar arg optarg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
@@ -148,7 +162,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
+          send_nodes = node.each_descendant(:call, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -191,9 +205,7 @@ module RuboCop
 
           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)
+              if allow_anonymous_forwarding_in_block?(forward_block_arg)
                 register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
                 register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
               end
@@ -214,24 +226,22 @@ 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)
+          return unless all_forwarding_offenses_correctable?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
           send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if outside_block?(forward_rest)
+            if allow_anonymous_forwarding_in_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if outside_block?(forward_kwrest)
+            if allow_anonymous_forwarding_in_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
 
-            # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-            # in Ruby 3.3.0.
-            if outside_block?(forward_block_arg)
+            if allow_anonymous_forwarding_in_block?(forward_block_arg)
               register_forward_block_arg_offense(!forward_rest, def_node.arguments, block_arg)
               register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
             end
@@ -293,10 +303,25 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
-        def outside_block?(node)
+        # Checks if forwarding is uses both in blocks and outside of blocks.
+        # On Ruby 3.3.0, anonymous block forwarding in blocks can be is a syntax
+        # error, so we only want to register an offense if we can change all occurrences.
+        def all_forwarding_offenses_correctable?(send_classifications)
+          return true if target_ruby_version >= 3.4
+
+          send_classifications.none? do |send_node, *|
+            send_node.each_ancestor(:any_block).any?
+          end
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def allow_anonymous_forwarding_in_block?(node)
           return false unless node
+          return true if target_ruby_version >= 3.4
 
-          node.each_ancestor(:block, :numblock).none?
+          node.each_ancestor(:any_block).none?
         end
 
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
@@ -357,12 +382,6 @@ 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?(:[])
@@ -460,6 +479,9 @@ module RuboCop
           end
 
           def ruby_32_only_anonymous_forwarding?
+            # A block argument and an anonymous block argument are never passed together.
+            return false if @send_node.each_ancestor(:any_block).any?
+
             def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
           end
 
@@ -511,7 +533,7 @@ module RuboCop
           end
 
           def additional_kwargs?
-            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+            @def_node.arguments.any? { |a| a.type?(:kwarg, :kwoptarg) }
           end
 
           def forward_additional_kwargs?
@@ -540,10 +562,7 @@ module RuboCop
         end
 
         def explicit_block_name?
-          block_forwarding_config = config.for_cop('Naming/BlockForwarding')
-          return false unless block_forwarding_config['Enabled']
-
-          block_forwarding_config['EnforcedStyle'] == 'explicit'
+          config.for_enabled_cop('Naming/BlockForwarding')['EnforcedStyle'] == 'explicit'
         end
       end
     end

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

@@ -42,14 +42,30 @@ module RuboCop
           return if node.parent && brace_method?(node.parent)
 
           preferred = (value.zero? ? 'first' : 'last')
-          add_offense(node.loc.selector, message: format(MSG, preferred: preferred)) do |corrector|
-            corrector.replace(node.loc.selector, ".#{preferred}")
+          offense_range = find_offense_range(node)
+
+          add_offense(offense_range, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(offense_range, preferred_value(node, preferred))
           end
         end
         # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
 
         private
 
+        def preferred_value(node, value)
+          value = ".#{value}" unless node.loc.dot
+          value
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.selector.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
         def innermost_braces_node(node)
           node = node.receiver while node.receiver.send_type? && node.receiver.method?(:[])
           node

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

@@ -6,7 +6,8 @@ module RuboCop
       # In Ruby 3.1, `Array#intersect?` has been added.
       #
       # This cop identifies places where `(array1 & array2).any?`
-      # can be replaced by `array1.intersect?(array2)`.
+      # or `(array1.intersection(array2)).any?` can be replaced by
+      # `array1.intersect?(array2)`.
       #
       # The `array1.intersect?(array2)` method is faster than
       # `(array1 & array2).any?` and is more readable.
@@ -20,6 +21,10 @@ module RuboCop
       # [1].intersect?([1,2]) { |x| false } # => true
       # ----
       #
+      # NOTE: Although `Array#intersection` can take zero or multiple arguments,
+      # only cases where exactly one argument is provided can be replaced with
+      # `Array#intersect?` and are handled by this cop.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -30,6 +35,11 @@ module RuboCop
       #   (array1 & array2).empty?
       #   (array1 & array2).none?
       #
+      #   # bad
+      #   array1.intersection(array2).any?
+      #   array1.intersection(array2).empty?
+      #   array1.intersection(array2).none?
+      #
       #   # good
       #   array1.intersect?(array2)
       #   !array1.intersect?(array2)
@@ -53,65 +63,66 @@ module RuboCop
 
         minimum_target_ruby_version 3.1
 
-        # @!method regular_bad_intersection_check?(node)
-        def_node_matcher :regular_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:any? :empty? :none?}
-          )
-        PATTERN
+        PREDICATES = %i[any? empty? none?].to_set.freeze
+        ACTIVE_SUPPORT_PREDICATES = (PREDICATES + %i[present? blank?]).freeze
 
-        # @!method active_support_bad_intersection_check?(node)
-        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:present? :any? :blank? :empty? :none?}
+        # @!method bad_intersection_check?(node, predicates)
+        def_node_matcher :bad_intersection_check?, <<~PATTERN
+          (call
+            {
+              (begin (send $_ :& $_))
+              (call $_ :intersection $_)
+            }
+            $%1
           )
         PATTERN
 
-        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
-              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
+        MSG = 'Use `%<negated>s%<receiver>s%<dot>sintersect?(%<argument>s)` ' \
+              'instead of `%<existing>s`.'
         STRAIGHT_METHODS = %i[present? any?].freeze
         NEGATED_METHODS = %i[blank? empty? none?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
           return if node.block_literal?
-          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+          return unless (receiver, argument, method_name = bad_intersection?(node))
 
-          message = message(receiver.source, argument.source, method_name)
+          dot = node.loc.dot.source
+          message = message(receiver.source, argument.source, method_name, dot, node.source)
 
           add_offense(node, message: message) do |corrector|
             bang = straight?(method_name) ? '' : '!'
 
-            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
+            corrector.replace(node, "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})")
           end
         end
+        alias on_csend on_send
 
         private
 
-        def bad_intersection_check?(node)
-          if active_support_extensions_enabled?
-            active_support_bad_intersection_check?(node)
-          else
-            regular_bad_intersection_check?(node)
-          end
+        def bad_intersection?(node)
+          predicates = if active_support_extensions_enabled?
+                         ACTIVE_SUPPORT_PREDICATES
+                       else
+                         PREDICATES
+                       end
+
+          bad_intersection_check?(node, predicates)
         end
 
         def straight?(method_name)
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
-        def message(receiver, argument, method_name)
+        def message(receiver, argument, method_name, dot, existing)
           negated = straight?(method_name) ? '' : '!'
           format(
             MSG,
             negated: negated,
             receiver: receiver,
             argument: argument,
-            method_name: method_name
+            dot: dot,
+            existing: existing
           )
         end
       end

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

@@ -183,7 +183,8 @@ module RuboCop
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
-          return if node.operator_method? || node.assignment_method?
+          return if node.assignment_method?
+          return if single_argument_operator_method?(node)
 
           node.arguments.each do |arg|
             get_blocks(arg) do |block|
@@ -194,6 +195,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           return if ignored_node?(node)
@@ -206,6 +208,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -342,16 +345,23 @@ module RuboCop
           node.respond_to?(:block_node) && node.block_node
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             yield node
-          when :send
+          when :send, :csend
+            # When a method has an argument which is another method with a block,
+            # that block needs braces, otherwise a syntax error will be introduced
+            # for subsequent arguments.
+            # Additionally, even without additional arguments, changing `{...}` to
+            # `do...end` will change the binding of the block to the outer method.
             get_blocks(node.receiver, &block) if node.receiver
+            node.arguments.each { |argument| get_blocks(argument, &block) }
           when :hash
             # A hash which is passed as method argument may have no braces
             # In that case, one of the K/V pairs could contain a block node
-            # which could change in meaning if do...end replaced {...}
+            # which could change in meaning if `do...end` is replaced with `{...}`
             return if node.braces?
 
             node.each_child_node { |child| get_blocks(child, &block) }
@@ -359,10 +369,10 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node) || require_do_end?(node)
+          return true if require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -372,15 +382,6 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def require_braces?(node)
-          return false unless node.braces?
-
-          node.each_ancestor(:send).any? do |send|
-            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
-          end
-        end
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
@@ -474,18 +475,14 @@ module RuboCop
         end
 
         def return_value_of_scope?(node)
-          return false unless node.parent
-
-          conditional?(node.parent) || array_or_range?(node.parent) ||
-            node.parent.children.last == node
-        end
+          return false unless (parent = node.parent)
 
-        def conditional?(node)
-          node.if_type? || node.operator_keyword?
+          parent.conditional? || parent.operator_keyword? || array_or_range?(parent) ||
+            parent.children.last == node
         end
 
         def array_or_range?(node)
-          node.array_type? || node.range_type?
+          node.type?(:array, :range)
         end
 
         def begin_required?(block_node)
@@ -493,6 +490,12 @@ module RuboCop
           # `begin`...`end` when changing `do-end` to `{}`.
           block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
         end
+
+        def single_argument_operator_method?(node)
+          return false unless node.operator_method?
+
+          node.arguments.one? && node.first_argument.block_type?
+        end
       end
     end
   end