rubocop 1.71.1 → 1.91.0

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

@@ -45,7 +45,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|
@@ -61,7 +61,7 @@ module RuboCop
         def arguments_match?(arguments, def_node)
           index = 0
 
-          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+          all_present = def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
             send_arg = arguments[index]
             case def_arg.type
             when :arg, :restarg, :optarg
@@ -70,9 +70,72 @@ module RuboCop
 
             send_arg && argument_match?(send_arg, def_arg)
           end
+
+          all_present &&
+            !extra_positional_arguments?(arguments, def_node) &&
+            !extra_keyword_arguments?(arguments, def_node)
+        end
+
+        # The enumerator re-invokes the method with these arguments, so passing more
+        # positional arguments than the method accepts raises `ArgumentError` at runtime.
+        def extra_positional_arguments?(arguments, def_node)
+          return false if variadic_parameters?(def_node) || expandable_arguments?(arguments)
+
+          positional_arguments(arguments).size > positional_parameters(def_node).size
+        end
+
+        def variadic_parameters?(def_node)
+          def_node.arguments.any? { |arg| arg.type?(:restarg, :forward_arg) }
+        end
+
+        # A splat or argument forwarding on the call side can expand to any arity.
+        def expandable_arguments?(arguments)
+          arguments.any? { |arg| arg.type?(:splat, :forwarded_args, :forwarded_restarg) }
+        end
+
+        def positional_arguments(arguments)
+          arguments.reject { |arg| arg.type?(:hash, :kwsplat, :block_pass, :forwarded_kwrestarg) }
+        end
+
+        def positional_parameters(def_node)
+          def_node.arguments.select { |arg| arg.type?(:arg, :optarg) }
+        end
+
+        # The enumerator re-invokes the method with these arguments, so passing
+        # unexpected keyword arguments raises `ArgumentError` at runtime.
+        def extra_keyword_arguments?(arguments, def_node)
+          return false if variadic_keyword_parameters?(def_node)
+          return false if expandable_keyword_arguments?(arguments)
+
+          (passed_keyword_arguments(arguments) - keyword_parameters(def_node)).any?
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def variadic_keyword_parameters?(def_node)
+          def_node.arguments.any? { |arg| arg.type?(:kwrestarg, :forward_arg) }
+        end
+
+        # A call-side keyword splat or argument forwarding can expand to any set of keywords.
+        def expandable_keyword_arguments?(arguments)
+          arguments.any? do |arg|
+            arg.forwarded_args_type? || arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any?
+          end
+        end
+
+        def passed_keyword_arguments(arguments)
+          arguments.filter_map do |arg|
+            next unless arg.hash_type?
+
+            arg.pairs.filter_map { |pair| pair.key.value if pair.key.sym_type? }
+          end.flatten
+        end
+
+        def keyword_parameters(def_node)
+          def_node.arguments.filter_map do |arg|
+            arg.children[0] if arg.type?(:kwarg, :kwoptarg)
+          end
+        end
+
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -82,9 +145,11 @@ module RuboCop
           when :optarg
             send_arg.source == def_arg_name.to_s
           when :kwoptarg, :kwarg
-            send_arg.hash_type? &&
+            keyword_hash_argument?(send_arg) &&
               send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
           when :kwrestarg
+            return false unless keyword_hash_argument?(send_arg)
+
             send_arg.each_child_node(:kwsplat, :forwarded_kwrestarg).any? do |child|
               child.source == def_arg.source
             end
@@ -92,7 +157,10 @@ module RuboCop
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def keyword_hash_argument?(send_arg)
+          send_arg.hash_type? && !send_arg.braces?
+        end
       end
     end
   end

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

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base
@@ -40,9 +36,16 @@ module RuboCop
             # The following used `*_args` because `to_json(*args)` has
             # an offense of `Lint/UnusedMethodArgument` cop if `*args`
             # is not used.
-            corrector.insert_after(node.loc.name, '(*_args)')
+            if (opening_parenthesis = node.each_child_node(:args).first.loc.begin)
+              # Explicit empty parentheses (`def to_json()`) are already present,
+              # so insert the argument inside them to avoid producing `to_json(*_args)()`.
+              corrector.insert_after(opening_parenthesis, '*_args')
+            else
+              corrector.insert_after(node.loc.name, '(*_args)')
+            end
           end
         end
+        alias on_defs on_def
       end
     end
   end

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

@@ -40,7 +40,7 @@ module RuboCop
         # top-level return node's ancestors should not be of block, def, or
         # defs type.
         def top_level_return?(return_node)
-          return_node.each_ancestor(:block, :def, :defs).none?
+          return_node.each_ancestor(:any_block, :any_def).none?
         end
       end
     end

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

@@ -32,9 +32,13 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
-          return unless node.attribute_accessor? && node.last_argument.def_type?
+          return unless node.attribute_accessor? && node.last_argument.any_def_type?
+          # A lone `def` argument (e.g. `attr_reader def foo; end`) has no preceding
+          # attribute, so there is no trailing comma to flag.
+          return unless node.arguments.size > 1
 
           trailing_comma = trailing_comma_range(node)
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # Checks for Regexps (both literals and via `Regexp.new` / `Regexp.compile`)
       # that contain unescaped `]` characters.
       #
       # It emulates the following Ruby warning:
@@ -44,9 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           RuboCop::Util.silence_warnings do
-            node.parsed_tree&.each_expression do |expr|
-              detect_offenses(node, expr)
-            end
+            detect_offenses_in_tree(node, node.parsed_tree)
           end
         end
 
@@ -55,20 +53,46 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            parse_regexp(text.value)&.each_expression do |expr|
-              detect_offenses(text, expr)
-            end
+            detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
-        def detect_offenses(node, expr)
-          return unless expr.type?(:literal)
+        # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses
+        # `[^]` / `[]` as an empty set and reports the closing `]` as a separate literal.
+        # Ruby treats that `]` as the end of the class, not as an unescaped bracket,
+        # so the first `]` following an empty set must be skipped.
+        def detect_offenses_in_tree(node, tree)
+          return unless tree
+
+          skip_class_closer = false
+          tree.each_expression do |expr|
+            if empty_character_set?(expr)
+              skip_class_closer = true
+            elsif expr.type?(:literal)
+              skip_class_closer = detect_offenses(node, expr, skip_class_closer)
+            end
+          end
+        end
+
+        def empty_character_set?(expr)
+          expr.type?(:set) && expr.expressions.empty?
+        end
 
+        def detect_offenses(node, expr, skip_class_closer)
           expr.text.scan(/(?<!\\)\]/) do
             pos = Regexp.last_match.begin(0)
-            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+
+            # The first `]` following an empty `[^]` / `[]` set closes the character class.
+            if skip_class_closer
+              skip_class_closer = false
+              next
+            end
+
+            # If the unescaped bracket is the first character of the regexp, Ruby does not warn.
+            # `pos` is relative to the sub-expression, so add its start offset (`expr.ts`).
+            next if (expr.ts + pos).zero?
 
             location = range_at_index(node, expr.ts, pos)
 
@@ -76,6 +100,8 @@ module RuboCop
               corrector.replace(location, '\]')
             end
           end
+
+          skip_class_closer
         end
 
         def range_at_index(node, index, offset)

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

@@ -53,6 +53,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -74,6 +75,7 @@ module RuboCop
 
         def arg_count(node)
           return node.children[1] if node.numblock_type? # the maximum numbered param for the block
+          return 1 if node.itblock_type? # `it` block parameter is always one
 
           # Only `arg`, `optarg` and `mlhs` (destructuring) count as arguments that
           # can be used. Keyword arguments are not used for these methods so are

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

@@ -120,6 +120,7 @@ module RuboCop
           check_return_values(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -130,7 +131,7 @@ module RuboCop
 
           block_body_node.each_descendant(:next, :break) do |n|
             # Ignore `next`/`break` inside an inner block
-            next if n.each_ancestor(:block).first != block_body_node.parent
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
             next unless n.first_argument
 
             nodes << n.first_argument

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in `begin` (implicit) blocks.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #
@@ -43,6 +43,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def after_block(node)
           @instance_eval_count -= 1 if instance_eval_block?(node)
@@ -51,10 +52,15 @@ module RuboCop
         def on_begin(node)
           expressions = *node
 
-          expressions.each_cons(2) do |expression1, expression2|
-            next unless flow_expression?(expression1)
-
-            add_offense(expression2)
+          # Once a flow-of-control statement is reached, every following statement
+          # in the block is unreachable, not just the one immediately after it.
+          flow_reached = false
+          expressions.each_with_index do |expression, index|
+            if flow_reached
+              add_offense(expression)
+            elsif index < expressions.size - 1 && flow_expression?(expression)
+              flow_reached = true
+            end
           end
         end
 
@@ -77,6 +83,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable-next Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -88,8 +95,9 @@ module RuboCop
             check_if(node)
           when :case, :case_match
             check_case(node)
-          when :def
+          when :def, :defs
             register_redefinition(node)
+            false
           else
             false
           end
@@ -112,8 +120,7 @@ module RuboCop
         end
 
         def register_redefinition(node)
-          @redefined << node.method_name if redefinable_flow_method? node.method_name
-          false
+          @redefined << node.method_name if redefinable_flow_method?(node.method_name)
         end
 
         def instance_eval_block?(node)

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

@@ -101,9 +101,8 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
-        def on_numblock(node)
-          check(node) if loop_method?(node)
-        end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -189,8 +188,9 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
-            # Numblocks have the arguments count as a number in the AST.
-            next if sibling.is_a?(Integer)
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unreachable `in` pattern branches in `case...in` statements.
+      #
+      # An `in` branch is unreachable when a previous branch uses an unguarded
+      # catch-all pattern that matches any value unconditionally. Any `in` branches
+      # (and `else`) that follow such a catch-all are dead code.
+      #
+      # A catch-all pattern is one of:
+      #
+      # * A bare variable capture (`in x`)
+      # * An underscore (`in _`)
+      # * A pattern alias where the left side is a catch-all (`in _ => y`)
+      # * An alternation pattern where at least one alternative is a catch-all
+      #   (`in _ | Integer`)
+      #
+      # NOTE: A catch-all pattern with a guard clause (e.g., `in _ if condition`)
+      # does NOT make subsequent branches unreachable because the guard might
+      # not be satisfied.
+      #
+      # @example
+      #
+      #   # bad
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in x
+      #     handle_other
+      #   in String
+      #     handle_string
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in String
+      #     handle_string
+      #   in x
+      #     handle_other
+      #   end
+      #
+      #   # bad - else is unreachable after catch-all
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in _
+      #     handle_other
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good - guard clause means catch-all might not match
+      #   case value
+      #   in x if x.positive?
+      #     handle_positive
+      #   in Integer
+      #     handle_integer
+      #   else
+      #     handle_other
+      #   end
+      #
+      class UnreachablePatternBranch < Base
+        extend TargetRubyVersion
+
+        MSG = 'Unreachable `in` pattern branch detected.'
+        MSG_ELSE = 'Unreachable `else` branch detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          catch_all_found = false
+
+          case_node.in_pattern_branches.each do |in_pattern_node|
+            if catch_all_found
+              add_offense(in_pattern_node)
+              next
+            end
+
+            pattern = in_pattern_node.pattern
+            guard = in_pattern_node.children[1]
+
+            catch_all_found = true if catch_all_pattern?(pattern) && guard.nil?
+          end
+
+          return unless catch_all_found && case_node.else?
+
+          add_offense(case_node.loc.else, message: MSG_ELSE)
+        end
+
+        private
+
+        def catch_all_pattern?(pattern)
+          case pattern.type
+          when :match_var
+            true
+          when :match_as, :begin
+            catch_all_pattern?(pattern.children[0])
+          when :match_alt
+            pattern.children.any? { |child| catch_all_pattern?(child) }
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -95,10 +95,20 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? && cop_config['AllowUnusedKeywordArguments']
           return if ignored_method?(variable.scope.node.body)
+          return if block_argument_with_yield?(variable)
 
           super
         end
 
+        def block_argument_with_yield?(variable)
+          return false unless variable.declaration_node.blockarg_type?
+
+          method_body = variable.scope.node.body
+          return false unless method_body
+
+          method_body.yield_type? || method_body.each_descendant(:yield).any?
+        end
+
         def ignored_method?(body)
           (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
             (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))