rubocop 1.18.0 → 1.56.0

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

@@ -8,6 +8,12 @@ module RuboCop
       # This cop identifies places where `do_something(*args, &block)`
       # can be replaced by `do_something(...)`.
       #
+      # 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.
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -24,13 +30,37 @@ module RuboCop
       #     bar(...)
       #   end
       #
-      # @example AllowOnlyRestArgument: true (default)
+      # @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2)
+      #   # bad
+      #   def foo(*args, **kwargs)
+      #     args_only(*args)
+      #     kwargs_only(**kwargs)
+      #   end
+      #
+      #   # good
+      #   def foo(*, **)
+      #     args_only(*)
+      #     kwargs_only(**)
+      #   end
+      #
+      # @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2)
+      #   # good
+      #   def foo(*args, **kwargs)
+      #     args_only(*args)
+      #     kwargs_only(**kwargs)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2)
       #   # good
       #   def foo(*args)
       #     bar(*args)
       #   end
       #
-      # @example AllowOnlyRestArgument: false
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: false (only relevant for Ruby < 3.2)
       #   # bad
       #   # The following code can replace the arguments with `...`,
       #   # but it will change the behavior. Because `...` forwards block also.
@@ -38,6 +68,10 @@ module RuboCop
       #     bar(*args)
       #   end
       #
+      #   def foo(**kwargs)
+      #     bar(**kwargs)
+      #   end
+      #
       class ArgumentsForwarding < Base
         include RangeHelp
         extend AutoCorrector
@@ -45,98 +79,282 @@ module RuboCop
 
         minimum_target_ruby_version 2.7
 
-        MSG = 'Use arguments forwarding.'
-
-        # @!method use_rest_arguments?(node)
-        def_node_matcher :use_rest_arguments?, <<~PATTERN
-          (args (restarg $_) $...)
-        PATTERN
-
-        # @!method only_rest_arguments?(node, name)
-        def_node_matcher :only_rest_arguments?, <<~PATTERN
-          (send _ _ (splat (lvar %1)))
-        PATTERN
-
-        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
-        def_node_matcher :forwarding_method_arguments?, <<~PATTERN
-          {
-            (send _ _
-              (splat (lvar %1))
-              (block-pass (lvar %2)))
-            (send _ _
-              (splat (lvar %1))
-              (hash (kwsplat (lvar %3)))
-              (block-pass (lvar %2)))
-          }
-        PATTERN
+        FORWARDING_LVAR_TYPES = %i[splat kwsplat block_pass].freeze
+
+        FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
+        ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
+        KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
 
         def on_def(node)
           return unless node.body
-          return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
 
-          node.each_descendant(:send) do |send_node|
-            kwargs_name, block_name = extract_argument_names_from(args)
+          forwardable_args = extract_forwardable_args(node.arguments)
 
-            next unless forwarding_method?(send_node, rest_args_name, kwargs_name, block_name) &&
-                        all_lvars_as_forwarding_method_arguments?(node, send_node)
+          send_classifications = classify_send_nodes(
+            node,
+            node.each_descendant(:send).to_a,
+            non_splat_or_block_pass_lvar_references(node.body),
+            forwardable_args
+          )
 
-            register_offense_to_forwarding_method_arguments(send_node)
-            register_offense_to_method_definition_arguments(node)
+          return if send_classifications.empty?
+
+          if only_forwards_all?(send_classifications)
+            add_forward_all_offenses(node, send_classifications, forwardable_args)
+          elsif target_ruby_version >= 3.2
+            add_post_ruby_32_offenses(node, send_classifications, forwardable_args)
           end
         end
+
         alias on_defs on_def
 
         private
 
-        def extract_argument_names_from(args)
-          kwargs_name = args.first.source.delete('**') if args.first&.kwrestarg_type?
-          block_arg_name = args.last.source.delete('&') if args.last&.blockarg_type?
+        def extract_forwardable_args(args)
+          [args.find(&:restarg_type?), args.find(&:kwrestarg_type?), args.find(&:blockarg_type?)]
+        end
+
+        def only_forwards_all?(send_classifications)
+          send_classifications.each_value.all? { |c, _, _| c == :all }
+        end
+
+        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)
+          end
 
-          [kwargs_name, block_arg_name].map { |name| name&.to_sym }
+          rest_arg, _kwrest_arg, _block_arg = *forwardable_args
+          register_forward_all_offense(node, node.arguments, rest_arg)
         end
 
-        def forwarding_method?(node, rest_arg, kwargs, block_arg)
-          return only_rest_arguments?(node, rest_arg) unless allow_only_rest_arguments?
+        def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
+          return unless use_anonymous_forwarding?
+
+          rest_arg, kwrest_arg, _block_arg = *forwardable_args
+
+          send_classifications.each do |send_node, (_c, forward_rest, forward_kwrest)|
+            if forward_rest
+              register_forward_args_offense(def_node.arguments, rest_arg)
+              register_forward_args_offense(send_node, forward_rest)
+            end
 
-          forwarding_method_arguments?(node, rest_arg, block_arg, kwargs)
+            if forward_kwrest
+              register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
+              register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
+            end
+          end
         end
 
-        def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method)
-          lvars = def_node.body.each_descendant(:lvar, :lvasgn)
+        def non_splat_or_block_pass_lvar_references(body)
+          body.each_descendant(:lvar, :lvasgn).filter_map do |lvar|
+            parent = lvar.parent
 
-          begin_pos = forwarding_method.source_range.begin_pos
-          end_pos = forwarding_method.source_range.end_pos
+            next if lvar.lvar_type? && FORWARDING_LVAR_TYPES.include?(parent.type)
 
-          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
+            lvar.children.first
+          end.uniq
         end
 
-        def register_offense_to_forwarding_method_arguments(forwarding_method)
-          add_offense(arguments_range(forwarding_method)) do |corrector|
-            range = range_between(
-              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
+        def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args)
+          send_nodes.to_h do |send_node|
+            classification_and_forwards = classification_and_forwards(
+              def_node,
+              send_node,
+              referenced_lvars,
+              forwardable_args
             )
-            corrector.replace(range, '(...)')
+
+            [send_node, classification_and_forwards]
+          end.compact
+        end
+
+        def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
+          classifier = SendNodeClassifier.new(
+            def_node,
+            send_node,
+            referenced_lvars,
+            forwardable_args,
+            target_ruby_version: target_ruby_version,
+            allow_only_rest_arguments: allow_only_rest_arguments?
+          )
+
+          classification = classifier.classification
+
+          return unless classification
+
+          [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
+        end
+
+        def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
+          add_offense(rest_arg_or_splat, message: ARGS_MSG) do |corrector|
+            add_parens_if_missing(def_arguments_or_send, corrector)
+
+            corrector.replace(rest_arg_or_splat, '*')
           end
         end
 
-        def register_offense_to_method_definition_arguments(method_definition)
-          add_offense(arguments_range(method_definition)) do |corrector|
-            arguments_range = range_with_surrounding_space(
-              range: method_definition.arguments.source_range, side: :left
-            )
-            corrector.replace(arguments_range, '(...)')
+        def register_forward_kwargs_offense(add_parens, def_arguments_or_send, kwrest_arg_or_splat)
+          add_offense(kwrest_arg_or_splat, message: KWARGS_MSG) do |corrector|
+            add_parens_if_missing(def_arguments_or_send, corrector) if add_parens
+
+            corrector.replace(kwrest_arg_or_splat, '**')
           end
         end
 
-        def arguments_range(node)
+        def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat)
+          arg_range = arguments_range(def_or_send, rest_or_splat)
+
+          add_offense(arg_range, message: FORWARDING_MSG) do |corrector|
+            add_parens_if_missing(send_or_arguments, corrector)
+
+            corrector.replace(arg_range, '...')
+          end
+        end
+
+        def arguments_range(node, first_node)
           arguments = node.arguments
 
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
+          start_node = first_node || arguments.first
+
+          range_between(start_node.source_range.begin_pos, arguments.last.source_range.end_pos)
         end
 
         def allow_only_rest_arguments?
           cop_config.fetch('AllowOnlyRestArgument', true)
         end
+
+        def use_anonymous_forwarding?
+          cop_config.fetch('UseAnonymousForwarding', false)
+        end
+
+        def add_parens_if_missing(node, corrector)
+          return if parentheses?(node)
+
+          add_parentheses(node, corrector)
+        end
+
+        # Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
+        class SendNodeClassifier
+          extend NodePattern::Macros
+
+          # @!method forwarded_rest_arg?(node, rest_name)
+          def_node_matcher :forwarded_rest_arg?, '(splat (lvar %1))'
+
+          # @!method extract_forwarded_kwrest_arg(node, kwrest_name)
+          def_node_matcher :extract_forwarded_kwrest_arg, '(hash <$(kwsplat (lvar %1)) ...>)'
+
+          # @!method forwarded_block_arg?(node, block_name)
+          def_node_matcher :forwarded_block_arg?, '(block_pass {(lvar %1) nil?})'
+
+          def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config)
+            @def_node = def_node
+            @send_node = send_node
+            @referenced_lvars = referenced_lvars
+            @rest_arg, @kwrest_arg, @block_arg = *forwardable_args
+            @rest_arg_name, @kwrest_arg_name, @block_arg_name =
+              *forwardable_args.map { |a| a&.name }
+            @config = config
+          end
+
+          def forwarded_rest_arg
+            return nil if referenced_rest_arg?
+
+            arguments.find { |arg| forwarded_rest_arg?(arg, @rest_arg_name) }
+          end
+
+          def forwarded_kwrest_arg
+            return nil if referenced_kwrest_arg?
+
+            arguments.filter_map { |arg| extract_forwarded_kwrest_arg(arg, @kwrest_arg_name) }.first
+          end
+
+          def forwarded_block_arg
+            return nil if referenced_block_arg?
+
+            arguments.find { |arg| forwarded_block_arg?(arg, @block_arg_name) }
+          end
+
+          def classification
+            return nil unless forwarded_rest_arg || forwarded_kwrest_arg
+
+            if can_forward_all?
+              :all
+            elsif target_ruby_version >= 3.2
+              :rest_or_kwrest
+            end
+          end
+
+          private
+
+          def can_forward_all?
+            return false if any_arg_referenced?
+            return false if ruby_32_missing_rest_or_kwest?
+            return false unless offensive_block_forwarding?
+            return false if forward_additional_kwargs?
+
+            no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
+          end
+
+          def ruby_32_missing_rest_or_kwest?
+            target_ruby_version >= 3.2 && !forwarded_rest_and_kwrest_args
+          end
+
+          def offensive_block_forwarding?
+            @block_arg ? forwarded_block_arg : allow_offense_for_no_block?
+          end
+
+          def forwarded_rest_and_kwrest_args
+            forwarded_rest_arg && forwarded_kwrest_arg
+          end
+
+          def arguments
+            @send_node.arguments
+          end
+
+          def referenced_rest_arg?
+            @referenced_lvars.include?(@rest_arg_name)
+          end
+
+          def referenced_kwrest_arg?
+            @referenced_lvars.include?(@kwrest_arg_name)
+          end
+
+          def referenced_block_arg?
+            @referenced_lvars.include?(@block_arg_name)
+          end
+
+          def any_arg_referenced?
+            referenced_rest_arg? || referenced_kwrest_arg? || referenced_block_arg?
+          end
+
+          def target_ruby_version
+            @config.fetch(:target_ruby_version)
+          end
+
+          def no_post_splat_args?
+            splat_index = arguments.index(forwarded_rest_arg)
+            arg_after_splat = arguments[splat_index + 1]
+
+            [nil, :hash, :block_pass].include?(arg_after_splat&.type)
+          end
+
+          def forward_additional_kwargs?
+            return false unless forwarded_kwrest_arg
+
+            !forwarded_kwrest_arg.parent.children.one?
+          end
+
+          def allow_offense_for_no_block?
+            !@config.fetch(:allow_only_rest_arguments)
+          end
+
+          def no_additional_args?
+            forwardable_count = [@rest_arg, @kwrest_arg, @block_arg].compact.size
+
+            @def_node.arguments.size == forwardable_count &&
+              @send_node.arguments.size == forwardable_count
+          end
+        end
       end
     end
   end

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

@@ -3,11 +3,29 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
+      # Enforces the use of `Array()` instead of explicit `Array` check or `[*var]`.
       #
-      # This cop is disabled by default because false positive will occur if
-      # the argument of `Array()` is not an array (e.g. Hash, Set),
-      # an array will be returned as an incompatibility result.
+      # The cop is disabled by default due to safety concerns.
+      #
+      # @safety
+      #   This cop is unsafe because a false positive may occur if
+      #   the argument of `Array()` is (or could be) nil or depending
+      #   on how the argument is handled by `Array()` (which can be
+      #   different than just wrapping the argument in an array).
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   [nil]             #=> [nil]
+      #   Array(nil)        #=> []
+      #
+      #   [{a: 'b'}]        #= [{a: 'b'}]
+      #   Array({a: 'b'})   #=> [[:a, 'b']]
+      #
+      #   [Time.now]        #=> [#<Time ...>]
+      #   Array(Time.now)   #=> [14, 16, 14, 16, 9, 2021, 4, 259, true, "EDT"]
+      #   ----
       #
       # @example
       #   # bad

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # In Ruby 3.1, `Array#intersect?` has been added.
+      #
+      # This cop identifies places where `(array1 & array2).any?`
+      # can be replaced by `array1.intersect?(array2)`.
+      #
+      # The `array1.intersect?(array2)` method is faster than
+      # `(array1 & array2).any?` and is more readable.
+      #
+      # @safety
+      #   This cop cannot guarantee that `array1` and `array2` are
+      #   actually arrays while method `intersect?` is for arrays only.
+      #
+      # @example
+      #   # bad
+      #   (array1 & array2).any?
+      #   (array1 & array2).empty?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      class ArrayIntersect < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        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?}
+          )
+        PATTERN
+
+        # @!method active_support_bad_intersection_check?(node)
+        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
+          (send
+            (begin
+              (send $(...) :& $(...))
+            ) ${:present? :any? :blank? :empty?}
+          )
+        PATTERN
+
+        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
+              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
+        STRAIGHT_METHODS = %i[present? any?].freeze
+        NEGATED_METHODS = %i[blank? empty?].freeze
+        RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
+
+        def on_send(node)
+          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+
+          message = message(receiver.source, argument.source, method_name)
+
+          add_offense(node, message: message) do |corrector|
+            if straight?(method_name)
+              corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
+            else
+              corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
+            end
+          end
+        end
+
+        private
+
+        def bad_intersection_check?(node)
+          if active_support_extensions_enabled?
+            active_support_bad_intersection_check?(node)
+          else
+            regular_bad_intersection_check?(node)
+          end
+        end
+
+        def straight?(method_name)
+          STRAIGHT_METHODS.include?(method_name.to_sym)
+        end
+
+        def message(receiver, argument, method_name)
+          negated = straight?(method_name) ? '' : '!'
+          format(
+            MSG,
+            negated: negated,
+            receiver: receiver,
+            argument: argument,
+            method_name: method_name
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of "*" as a substitute for _join_.
+      # Checks for uses of "*" as a substitute for _join_.
       #
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an

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

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Style
-      # This cop checks for non-ascii (non-English) characters
+      # Checks for non-ascii (non-English) characters
       # in comments. You could set an array of allowed non-ascii chars in
       # `AllowedChars` attribute (copyright notice "©" by default).
       #
@@ -32,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)
@@ -57,4 +55,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of Module#attr.
+      # Checks for uses of Module#attr.
       #
       # @example
       #   # bad - creates a single attribute accessor (deprecated in Ruby 1.9)
@@ -24,7 +24,7 @@ module RuboCop
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
           # check only for method definitions in class/module body
-          return if node.parent && !node.parent.class_type? && !class_eval?(node.parent)
+          return if allowed_context?(node)
 
           message = message(node)
           add_offense(node.loc.selector, message: message) do |corrector|
@@ -34,6 +34,16 @@ module RuboCop
 
         private
 
+        def allowed_context?(node)
+          return false unless (class_node = node.each_ancestor(:class, :block).first)
+
+          (!class_node.class_type? && !class_eval?(class_node)) || define_attr_method?(class_node)
+        end
+
+        def define_attr_method?(node)
+          node.each_descendant(:def).any? { |def_node| def_node.method?(:attr) }
+        end
+
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for cases when you could use a block
+      # Checks for cases when you could use a block
       # accepting version of a method that does automatic
       # resource cleanup.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks if usage of %() or %Q() matches configuration.
+      # Checks if usage of %() or %Q() matches configuration.
       #
       # @example EnforcedStyle: bare_percent (default)
       #   # bad

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop checks for BEGIN blocks.
+      # Checks for BEGIN blocks.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb

@@ -18,7 +18,7 @@ module RuboCop
 
           def initialize(node)
             @node = node
-            @attrs = node.arguments.map { |attr| [attr.source, attr] }.to_h
+            @attrs = node.arguments.to_h { |attr| [attr.source, attr] }
             @bisection = []
           end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `attr_reader` and `attr_writer`
+      # Checks for places where `attr_reader` and `attr_writer`
       # for the same method can be combined into single `attr_accessor`.
       #
       # @example
@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?