rubocop 1.57.1 → 1.81.6

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

@@ -8,11 +8,42 @@ module RuboCop
       # This cop identifies places where `do_something(*args, &block)`
       # can be replaced by `do_something(...)`.
       #
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`; if desired, this functionality can be disabled
+      # by setting `UseAnonymousForwarding: false`.
+      #
       # 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.
+      #
+      # 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
@@ -32,22 +63,25 @@ module RuboCop
       #
       # @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2)
       #   # bad
-      #   def foo(*args, **kwargs)
+      #   def foo(*args, **kwargs, &block)
       #     args_only(*args)
       #     kwargs_only(**kwargs)
+      #     block_only(&block)
       #   end
       #
       #   # good
-      #   def foo(*, **)
+      #   def foo(*, **, &)
       #     args_only(*)
       #     kwargs_only(**)
+      #     block_only(&)
       #   end
       #
       # @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2)
       #   # good
-      #   def foo(*args, **kwargs)
+      #   def foo(*args, **kwargs, &block)
       #     args_only(*args)
       #     kwargs_only(**kwargs)
+      #     block_only(&block)
       #   end
       #
       # @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2)
@@ -72,6 +106,38 @@ module RuboCop
       #     bar(**kwargs)
       #   end
       #
+      # @example RedundantRestArgumentNames: ['args', 'arguments'] (default)
+      #   # bad
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      #   # good
+      #   def foo(*)
+      #     bar(*)
+      #   end
+      #
+      # @example RedundantKeywordRestArgumentNames: ['kwargs', 'options', 'opts'] (default)
+      #   # bad
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
+      #   # good
+      #   def foo(**)
+      #     bar(**)
+      #   end
+      #
+      # @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default)
+      #   # bad - But it is good with `EnforcedStyle: explicit` set for `Naming/BlockForwarding`.
+      #   def foo(&block)
+      #     bar(&block)
+      #   end
+      #
+      #   # good
+      #   def foo(&)
+      #     bar(&)
+      #   end
       class ArgumentsForwarding < Base
         include RangeHelp
         extend AutoCorrector
@@ -80,22 +146,25 @@ module RuboCop
         minimum_target_ruby_version 2.7
 
         FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
-        ADDITIONAL_ARG_TYPES = %i[lvar arg].freeze
 
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
         KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
+        BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
+
+        def self.autocorrect_incompatible_with
+          [Naming::BlockForwarding]
+        end
 
         def on_def(node)
           return unless node.body
 
-          forwardable_args = extract_forwardable_args(node.arguments)
+          restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
+          forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
+          send_nodes = node.each_descendant(:call, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
-            node,
-            node.each_descendant(:send).to_a,
-            non_splat_or_block_pass_lvar_references(node.body),
-            forwardable_args
+            node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
           )
 
           return if send_classifications.empty?
@@ -115,36 +184,73 @@ module RuboCop
           [args.find(&:restarg_type?), args.find(&:kwrestarg_type?), args.find(&:blockarg_type?)]
         end
 
+        def redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
+          restarg_node = redundant_named_arg(restarg, 'RedundantRestArgumentNames', '*')
+          kwrestarg_node = redundant_named_arg(kwrestarg, 'RedundantKeywordRestArgumentNames', '**')
+          blockarg_node = redundant_named_arg(blockarg, 'RedundantBlockArgumentNames', '&')
+
+          [restarg_node, kwrestarg_node, blockarg_node]
+        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/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          send_classifications.each do |send_node, _c, forward_rest, _forward_kwrest|
-            register_forward_all_offense(send_node, send_node, forward_rest)
+          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 && c != :all_anonymous
+              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
+              registered_block_arg_offense = true
+              break
+            else
+              first_arg = forward_rest || forward_kwrest || forward_all_first_argument(send_node)
+              register_forward_all_offense(send_node, send_node, first_arg)
+            end
           end
 
-          rest_arg, _kwrest_arg, _block_arg = *forwardable_args
-          register_forward_all_offense(node, node.arguments, rest_arg)
+          return if registered_block_arg_offense
+
+          register_forward_all_offense(node, node.arguments, rest_arg || kwrest_arg)
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+        def forward_all_first_argument(node)
+          node.arguments.reverse_each.find(&:forwarded_restarg_type?)
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
+          return unless all_forwarding_offenses_correctable?(send_classifications)
 
-          rest_arg, kwrest_arg, _block_arg = *forwardable_args
+          rest_arg, kwrest_arg, block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
-            if forward_rest
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            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 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
+
+            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
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def non_splat_or_block_pass_lvar_references(body)
           body.each_descendant(:lvar, :lvasgn).filter_map do |lvar|
@@ -173,10 +279,7 @@ module RuboCop
 
         def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
           classifier = SendNodeClassifier.new(
-            def_node,
-            send_node,
-            referenced_lvars,
-            forwardable_args,
+            def_node, send_node, referenced_lvars, forwardable_args,
             target_ruby_version: target_ruby_version,
             allow_only_rest_arguments: allow_only_rest_arguments?
           )
@@ -185,7 +288,43 @@ module RuboCop
 
           return unless classification
 
-          [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
+          [
+            classification,
+            classifier.forwarded_rest_arg,
+            classifier.forwarded_kwrest_arg,
+            classifier.forwarded_block_arg
+          ]
+        end
+
+        def redundant_named_arg(arg, config_name, keyword)
+          return nil unless arg
+
+          redundant_arg_names = cop_config.fetch(config_name, []).map do |redundant_arg_name|
+            "#{keyword}#{redundant_arg_name}"
+          end << keyword
+
+          redundant_arg_names.include?(arg.source) ? arg : nil
+        end
+
+        # 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(:any_block).none?
         end
 
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
@@ -204,6 +343,17 @@ module RuboCop
           end
         end
 
+        def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
+          return if target_ruby_version <= 3.0 ||
+                    block_arg.nil? || block_arg.source == '&' || explicit_block_name?
+
+          add_offense(block_arg, message: BLOCK_MSG) do |corrector|
+            add_parens_if_missing(def_arguments_or_send, corrector) if add_parens
+
+            corrector.replace(block_arg, '&')
+          end
+        end
+
         def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat)
           arg_range = arguments_range(def_or_send, rest_or_splat)
 
@@ -215,11 +365,7 @@ module RuboCop
         end
 
         def arguments_range(node, first_node)
-          arguments = node.arguments.reject { |arg| ADDITIONAL_ARG_TYPES.include?(arg.type) }
-
-          start_node = first_node || arguments.first
-
-          range_between(start_node.source_range.begin_pos, arguments.last.source_range.end_pos)
+          first_node.source_range.begin.join(node.last_argument.source_range.end)
         end
 
         def allow_only_rest_arguments?
@@ -232,6 +378,7 @@ module RuboCop
 
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
+          return if node.send_type? && node.method?(:[])
 
           add_parentheses(node, corrector)
         end
@@ -249,6 +396,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
@@ -278,9 +442,11 @@ module RuboCop
           end
 
           def classification
-            return nil unless forwarded_rest_arg || forwarded_kwrest_arg
+            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
@@ -289,16 +455,31 @@ 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?
+            # A block argument and an anonymous block argument are never passed together.
+            return false if @send_node.each_ancestor(:any_block).any?
 
-          def ruby_32_missing_rest_or_kwest?
+            def_all_anonymous_args?(@def_node) && send_all_anonymous_args?(@send_node)
+          end
+
+          def ruby_32_or_higher_missing_rest_or_kwest?
             target_ruby_version >= 3.2 && !forwarded_rest_and_kwrest_args
           end
 
@@ -346,7 +527,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?
@@ -362,9 +543,20 @@ module RuboCop
           def no_additional_args?
             forwardable_count = [@rest_arg, @kwrest_arg, @block_arg].compact.size
 
+            return false if missing_rest_arg_or_kwrest_arg?
+
             @def_node.arguments.size == forwardable_count &&
               @send_node.arguments.size == forwardable_count
           end
+
+          def missing_rest_arg_or_kwrest_arg?
+            (@rest_arg_name && !forwarded_rest_arg) ||
+              (@kwrest_arg_name && !forwarded_kwrest_arg)
+          end
+        end
+
+        def explicit_block_name?
+          config.for_enabled_cop('Naming/BlockForwarding')['EnforcedStyle'] == 'explicit'
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `arr[0]` and `arr[-1]` and suggests to change
+      # them to use `arr.first` and `arr.last` instead.
+      #
+      # The cop is disabled by default due to safety concerns.
+      #
+      # @safety
+      #   This cop is unsafe because `[0]` or `[-1]` can be called on a Hash,
+      #   which returns a value for `0` or `-1` key, but changing these to use
+      #   `.first` or `.last` will return first/last tuple instead. Also, String
+      #   does not implement `first`/`last` methods.
+      #
+      # @example
+      #   # bad
+      #   arr[0]
+      #   arr[-1]
+      #
+      #   # good
+      #   arr.first
+      #   arr.last
+      #   arr[0] = 2
+      #   arr[0][-2]
+      #
+      class ArrayFirstLast < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred>s`.'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        # rubocop:disable Metrics/AbcSize
+        def on_send(node)
+          return unless node.arguments.size == 1 && node.first_argument.int_type?
+
+          value = node.first_argument.value
+          return unless [0, -1].include?(value)
+
+          node = innermost_braces_node(node)
+          return if node.parent && brace_method?(node.parent)
+
+          preferred = (value.zero? ? 'first' : 'last')
+          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
+        end
+
+        def brace_method?(node)
+          node.send_type? && (node.method?(:[]) || node.method?(:[]=))
+        end
+      end
+    end
+  end
+end