rubocop 1.71.1 → 1.91.0

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

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

@@ -4,10 +4,10 @@ module RuboCop
   module Cop
     module Lint
       # Checks for redundant access modifiers, including those with no
-      # code, those which are repeated, and leading `public` modifiers in a
-      # class or module body. Conditionally-defined methods are considered as
-      # always being defined, and thus access modifiers guarding such methods
-      # are not redundant.
+      # code, those which are repeated, those which are on top-level, and
+      # leading `public` modifiers in a class or module body.
+      # Conditionally-defined methods are considered as always being defined,
+      # and thus access modifiers guarding such methods are not redundant.
       #
       # This cop has `ContextCreatingMethods` option. The default setting value
       # is an empty array that means no method is specified.
@@ -58,6 +58,12 @@ module RuboCop
       #     private # this is redundant (no following methods are defined)
       #   end
       #
+      #   # bad
+      #   private # this is useless (access modifiers have no effect on top-level)
+      #
+      #   def method
+      #   end
+      #
       #   # good
       #   class Foo
       #     private # this is not redundant (a method is defined)
@@ -143,6 +149,18 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_begin(node)
+          return if node.parent
+
+          node.child_nodes.each do |child|
+            next unless child.send_type? && access_modifier?(child)
+
+            # This call always registers an offense for access modifier `child.method_name`
+            check_send_node(child, child.method_name, true)
+          end
+        end
 
         private
 
@@ -192,7 +210,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
@@ -210,7 +228,6 @@ module RuboCop
 
           [cur_vis, unused]
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?
@@ -256,6 +273,10 @@ module RuboCop
 
         def any_method_definition?(child)
           cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            # Some users still have `"included"` in their `MethodCreatingMethods` configurations,
+            # so to prevent Ruby method redefinition warnings let's just skip this value.
+            next if m == 'included'
+
             matcher_name = :"#{m}_method?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
@@ -278,7 +299,11 @@ module RuboCop
         end
 
         def any_context_creating_methods?(child)
+          # Some users still have `"included"` in their `ContextCreatingMethods` configurations,
+          # so to prevent Ruby method redefinition warnings let's just skip this value.
           cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            next if m == 'included'
+
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN

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

@@ -40,8 +40,6 @@ module RuboCop
       class UselessAssignment < Base
         extend AutoCorrector
 
-        include RangeHelp
-
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def self.joining_forces
@@ -52,32 +50,44 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            assignment_node = assignment.node
-            next if assignment.used? || part_of_ignored_node?(assignment_node)
+            check_for_unused_assignment(variable, assignment)
+          end
+        end
 
-            message = message_for_useless_assignment(assignment)
-            range = offense_range(assignment)
+        def check_for_unused_assignment(variable, assignment)
+          assignment_node = assignment.node
 
-            add_offense(range, message: message) do |corrector|
-              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
-              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
-              # the autocorrect will be skipped, even if the variable is unused.
-              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
-                next
-              end
+          return if ignored_assignment?(variable, assignment_node, assignment)
 
-              autocorrect(corrector, assignment)
-            end
+          message = message_for_useless_assignment(assignment)
+          range = offense_range(assignment)
 
-            ignore_node(assignment_node) if chained_assignment?(assignment_node)
+          add_offense(range, message: message) do |corrector|
+            next if uncorrectable_assignment?(assignment_node)
+
+            autocorrect(corrector, assignment)
           end
+
+          ignore_node(assignment_node) if chained_assignment?(assignment_node)
+        end
+
+        # Autocorrect is skipped when removing a variable would cause a syntax error
+        # (`x = 1, y = 2`), or where rewriting `x ||= 1`/`x &&= 1` to `x = 1` would raise
+        # `NameError` because the variable is not declared before the operator assignment.
+        def uncorrectable_assignment?(assignment_node)
+          sequential_assignment?(assignment_node) ||
+            assignment_node.parent&.or_asgn_type? ||
+            assignment_node.parent&.and_asgn_type?
+        end
+
+        def ignored_assignment?(variable, assignment_node, assignment)
+          assignment.used? || part_of_ignored_node?(assignment_node) ||
+            variable_in_loop_condition?(assignment_node, variable)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -104,6 +114,8 @@ module RuboCop
         end
 
         def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
           node.respond_to?(:expression) && node.expression&.lvasgn_type?
         end
 
@@ -161,7 +173,7 @@ module RuboCop
           node.receiver.nil? && !node.arguments?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, assignment)
           if assignment.exception_assignment?
             remove_exception_assignment_part(corrector, assignment.node)
@@ -177,15 +189,11 @@ module RuboCop
             remove_local_variable_assignment_part(corrector, assignment.node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def remove_exception_assignment_part(corrector, node)
-          corrector.remove(
-            range_between(
-              (node.parent.children.first&.source_range || node.parent.location.keyword).end_pos,
-              node.source_range.end_pos
-            )
-          )
+          range = node.parent.children.first&.source_range || node.parent.location.keyword
+
+          corrector.remove(range.end.join(node.source_range.end))
         end
 
         def rename_variable_with_underscore(corrector, node)
@@ -204,7 +212,28 @@ module RuboCop
         end
 
         def remove_local_variable_assignment_part(corrector, node)
-          corrector.replace(node, node.expression.source)
+          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
+        end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          return false if assignment_node.each_ancestor(:any_def).any?
+
+          loop_node = assignment_node.each_ancestor.find do |ancestor|
+            ancestor.type?(*VariableForce::LOOP_TYPES)
+          end
+
+          return false unless loop_node.respond_to?(:condition)
+
+          condition_node = loop_node.condition
+          variable_name = variable.name
+
+          return true if condition_node.lvar_type? && condition_node.children.first == variable_name
+
+          condition_node.each_descendant(:lvar) do |lvar_node|
+            return true if lvar_node.children.first == variable_name
+          end
+
+          false
         end
       end
     end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # Constant assignments that define classes or modules via `Class.new`, `Module.new`,
+      # `Struct.new`, or `Data.define` are allowed. Those forms are class and module definitions
+      # written with assignment syntax, and match the common practice of placing nested
+      # `class` / `module` bodies after `private` without intending private constant visibility.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      #   # good - class/module definitions via assignment, same as nested `class`/`module`
+      #   class Foo
+      #     private
+      #
+      #     def some_private_method
+      #     end
+      #
+      #     MyClass = Class.new
+      #     MyModule = Module.new
+      #     MyStruct = Struct.new(:name)
+      #     MyData = Data.define(:name)
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        # Matches class/module-like constant assignments. Nested `class` / `module`
+        # keyword definitions are not visited by this cop; these assignment forms are
+        # the equivalent syntax and should be treated the same way.
+        # @!method class_or_module_definition_assignment?(node)
+        def_node_matcher :class_or_module_definition_assignment?, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (any_block
+              {
+                (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+                (send (const {nil? cbase} :Data) :define ...)
+              }
+              ...)
+          }
+        PATTERN
+
+        def on_casgn(node)
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+          return if class_or_module_definition_assignment?(node.expression)
+
+          add_offense(node)
+        end
+
+        private
+
+        def after_private_modifier?(left_siblings)
+          access_modifier_candidates = left_siblings.compact.select do |left_sibling|
+            left_sibling.respond_to?(:bare_access_modifier?) && left_sibling.bare_access_modifier?
+          end
+
+          return false if access_modifier_candidates.empty?
+
+          access_modifier_candidates.last.command?(:private)
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for usage of method `fetch` or `Array.new` with default value argument
+      # and block. In such cases, block will always be used as default value.
+      #
+      # This cop emulates Ruby warning "block supersedes default value argument" which
+      # applies to `Array.new`, `Array#fetch`, `Hash#fetch`, `ENV.fetch` and
+      # `Thread#fetch`.
+      #
+      # A `fetch` call without a receiver is considered a custom method and does not register
+      # an offense.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver could have nonstandard implementation
+      #   of `fetch`, or be a class other than the one listed above.
+      #
+      #   It is also unsafe because default value argument could have side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   def x(a) = puts "side effect"
+      #   Array.new(5, x(1)) { 2 }
+      #   ----
+      #
+      #   so removing it would change behavior.
+      #
+      # @example
+      #   # bad
+      #   x.fetch(key, default_value) { block_value }
+      #   Array.new(size, default_value) { block_value }
+      #
+      #   # good
+      #   x.fetch(key) { block_value }
+      #   Array.new(size) { block_value }
+      #
+      #   # also good - in case default value argument is desired instead
+      #   x.fetch(key, default_value)
+      #   Array.new(size, default_value)
+      #
+      #   # good - keyword arguments aren't registered as offenses
+      #   x.fetch(key, keyword: :arg) { block_value }
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class UselessDefaultValueArgument < Base
+        include AllowedReceivers
+        extend AutoCorrector
+
+        MSG = 'Block supersedes default value argument.'
+
+        RESTRICT_ON_SEND = %i[fetch new].freeze
+
+        # @!method default_value_argument_and_block(node)
+        def_node_matcher :default_value_argument_and_block, <<~PATTERN
+          (any_block
+            {
+              (call !nil? :fetch $_key $_default_value)
+              (send (const _ :Array) :new $_size $_default_value)
+            }
+            _args
+            _block_body)
+        PATTERN
+
+        def on_send(node)
+          return unless node.receiver
+
+          unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
+            return
+          end
+          return if allowed_receiver?(node.receiver)
+          return if hash_without_braces?(default_value_node)
+
+          add_offense(default_value_node) do |corrector|
+            corrector.remove(prev_arg_node.source_range.end.join(default_value_node.source_range))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg, :kwrestarg) }
         end
 
         def delegating?(node, def_node)