rubocop 1.71.1 → 1.92.1

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,33 +53,78 @@ 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
+            next unless verbatim_string?(text)
+
+            detect_offenses_in_tree(text, parse_regexp(text.value))
           end
         end
 
         private
 
-        def detect_offenses(node, expr)
-          return unless expr.type?(:literal)
+        # Offsets into the string's value only point at the right place in the source
+        # when the string has no escape sequences, so anything else is left alone.
+        def verbatim_string?(node)
+          return false unless node.loc?(:begin) && node.loc?(:end)
+
+          node.loc.begin.end.join(node.loc.end.begin).source == node.value
+        end
+
+        # 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)
 
             add_offense(location) do |corrector|
-              corrector.replace(location, '\]')
+              corrector.replace(location, escaped_bracket(node))
             end
           end
+
+          skip_class_closer
         end
 
         def range_at_index(node, index, offset)
           adjustment = index + offset
           node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
         end
+
+        # A double-quoted string turns `\]` into `]`, so its backslash needs escaping too.
+        def escaped_bracket(node)
+          return '\]' if node.regexp_type? || node.single_quoted? || node.percent_literal?(:q)
+
+          '\\\\]'
+        end
       end
     end
   end

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))

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for private instance methods that are not referenced anywhere
+      # in the project.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # A method counts as referenced when a call with its name appears anywhere
+      # in the indexed project (regardless of the receiver), when it is the source
+      # of an `alias`, or when its name appears in the same file as a symbol or
+      # inside a string literal (covering `send(:name)` and declarative DSLs like
+      # `before_action :name`). An interpolated symbol or string with a literal
+      # prefix (e.g. `send(:"format_#{type}")`) counts as a reference to every
+      # method whose name starts with that prefix; fully dynamic names cannot
+      # be detected. Methods defined in classes or modules with descendants are
+      # not checked, since they may be invoked through `super` or inherited
+      # dispatch.
+      #
+      # Methods whose names are composed by a framework (e.g. Rails
+      # `attribute_method_suffix` generating `attribute?` methods) can be
+      # excluded from the check with `AllowedNames` (exact names) or
+      # `AllowedPatterns` (regular expressions).
+      #
+      # The cop is disabled by default because symbol-based references from
+      # *other* files (e.g. a Rails callback declared in a concern) cannot be
+      # detected and would be reported as false positives. It is best suited
+      # for occasional dead-code sweeps rather than permanent enforcement.
+      #
+      # @example
+      #   # bad - `helper` is never referenced anywhere in the project
+      #   class Service
+      #     def call
+      #       do_something
+      #     end
+      #
+      #     private
+      #
+      #     def helper
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Service
+      #     def call
+      #       do_something(helper)
+      #     end
+      #
+      #     private
+      #
+      #     def helper
+      #     end
+      #   end
+      #
+      # @example AllowedNames: ['attribute?']
+      #   # good - the name is explicitly allowed
+      #   class Contact
+      #     private
+      #
+      #     def attribute?
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['_hook\z']
+      #   # good - the name matches an allowed pattern
+      #   class Service
+      #     private
+      #
+      #     def before_save_hook
+      #     end
+      #   end
+      #
+      class UnusedPrivateMethod < Base
+        include AllowedPattern
+        include ProjectIndexHelp
+
+        MSG = 'Private method `%<method>s` appears to be unused.'
+
+        IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!=]?/.freeze
+        NAME_PREFIX_PATTERN = /[a-zA-Z_]\w*\z/.freeze
+
+        # Methods invoked implicitly by the Ruby runtime.
+        IMPLICITLY_INVOKED_METHODS = %i[
+          initialize initialize_copy initialize_clone initialize_dup
+          method_missing respond_to_missing? marshal_dump marshal_load
+          coerce instance_variables_to_inspect
+          inherited included extended prepended
+          append_features extend_object prepend_features
+          const_missing const_added
+          method_added method_removed method_undefined
+          singleton_method_added singleton_method_removed singleton_method_undefined
+        ].to_set.freeze
+
+        class << self
+          # The reference-name set is a property of the index, not of the cop
+          # instance, so all per-file instances share one computation. A
+          # single-entry cache (instead of a hash keyed by index) avoids
+          # retaining stale graphs in long-lived processes.
+          attr_accessor :cached_reference_names
+        end
+
+        def on_new_investigation
+          @literal_names = nil
+          @literal_name_prefixes = nil
+          super
+        end
+
+        def on_def(node)
+          return unless project_index
+
+          declaration = checkable_declaration(node)
+          return unless declaration
+          return if referenced?(node.method_name)
+          return if owner_with_descendants?(declaration) || override?(declaration, node.method_name)
+
+          message = format(MSG, method: node.method_name)
+          add_offense(node.loc.keyword.join(node.loc.name), message: message)
+        end
+
+        private
+
+        def checkable_declaration(node)
+          return nil if IMPLICITLY_INVOKED_METHODS.include?(node.method_name)
+          return nil if allowed_name?(node.method_name)
+          return nil if node.each_ancestor(:any_def, :any_block, :sclass).any?
+          return nil unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = method_declaration(node, namespace_node)
+          declaration if declaration&.private?
+        end
+
+        def allowed_name?(method_name)
+          name = method_name.to_s
+
+          cop_config.fetch('AllowedNames', []).include?(name) || matches_allowed_pattern?(name)
+        end
+
+        def method_declaration(node, namespace_node)
+          namespace = resolve_constant_in_index(namespace_node.identifier)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+
+          namespace.member("#{node.method_name}()")
+        end
+
+        def referenced?(method_name)
+          name = method_name.to_s
+
+          referenced_names.include?(name) || literal_names.include?(name) ||
+            literal_name_prefixes.any? { |prefix| name.start_with?(prefix) }
+        end
+
+        def referenced_names
+          index, names = self.class.cached_reference_names
+          return names if index.equal?(project_index)
+
+          compute_referenced_names.tap do |computed|
+            self.class.cached_reference_names = [project_index, computed]
+          end
+        end
+
+        def compute_referenced_names
+          project_index.method_references
+                       .to_set { |reference| reference.name.delete_suffix('()') }
+        end
+
+        # Symbol literals and identifier-like tokens inside string literals in the
+        # current file, covering `send(:name)`, declarative DSLs like
+        # `before_action :name` and names embedded in strings (e.g. node-pattern
+        # `#helper` references).
+        def literal_names
+          @literal_names ||=
+            processed_source.ast.each_descendant(:sym, :str)
+                            .with_object(Set.new) do |literal, names|
+              if literal.sym_type?
+                names << literal.value.to_s
+              else
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(IDENTIFIER_PATTERN) { |token| names << token }
+              end
+            end
+        end
+
+        # The leading literal fragment of an interpolated symbol or string acts
+        # as a method-name prefix: `send(:"format_#{type}")` may invoke any
+        # method whose name starts with `format_`. Only the leading fragment
+        # qualifies (a mid-string fragment is not a name prefix), and a fully
+        # dynamic name contributes nothing.
+        def literal_name_prefixes
+          @literal_name_prefixes ||=
+            processed_source.ast.each_descendant(:dsym, :dstr)
+                            .with_object(Set.new) do |literal, prefixes|
+              prefix = interpolation_prefix(literal)
+              prefixes << prefix if prefix
+            end
+        end
+
+        def interpolation_prefix(node)
+          return nil if node.children.all?(&:str_type?)
+
+          leading_fragment = node.children.first
+          return nil unless leading_fragment&.str_type?
+
+          leading_fragment.value[NAME_PREFIX_PATTERN]
+        end
+
+        # A method defined in a class or module with descendants may be invoked
+        # through `super` or inherited dispatch, which the index does not track.
+        def owner_with_descendants?(declaration)
+          owner = declaration.owner
+          return false unless owner.is_a?(Rubydex::Namespace)
+
+          owner.descendants.any? { |descendant| descendant.name != owner.name }
+        end
+
+        # An override of an inherited method may be invoked polymorphically
+        # (e.g. a framework hook), even when no direct reference exists.
+        def override?(declaration, method_name)
+          owner = declaration.owner
+          return false unless owner.is_a?(Rubydex::Namespace)
+
+          owner.ancestors.any? do |ancestor|
+            ancestor.name != owner.name && ancestor.member("#{method_name}()")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,7 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
+      #   URI.encode_uri_component(uri) # Since Ruby 3.1
       #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
       #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
@@ -27,6 +28,7 @@ module RuboCop
       #
       #   # good
       #   CGI.unescape(enc_uri)
+      #   URI.decode_uri_component(uri) # Since Ruby 3.1
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
       class UriEscapeUnescape < Base