rubocop 1.88.0 → 1.89.0

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+begin
+  require 'did_you_mean'
+rescue LoadError
+  nil
+end
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for probable typos in constant and method names: a name that
+      # does not resolve anywhere in the project, used in a namespace the
+      # project does define, with a close-named sibling to suggest instead.
+      #
+      # 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.
+      #
+      # Constants are checked only in qualified references (`Foo::Bar`) whose
+      # namespace resolves in the index; bare names cannot be distinguished
+      # from constants provided by gems or the standard library. Methods are
+      # checked only in calls on constant receivers (`Foo.bar`) whose entire
+      # indexed ancestry is resolved, so methods gained through gem classes or
+      # dynamic definitions never produce offenses. In both cases an offense
+      # requires a similarly named alternative to exist — an unknown name
+      # alone is not reported, since the index does not see gems or the
+      # standard library.
+      #
+      # Names that appear as symbols or inside string literals in the same
+      # file are never reported, since they usually belong to runtime
+      # definitions the index cannot see (`stub_const`, `const_set`,
+      # `define_method`, and the like).
+      #
+      # @example
+      #   # bad - Services::UserCraetor is not defined, Services::UserCreator is
+      #   Services::UserCraetor.new
+      #
+      #   # good
+      #   Services::UserCreator.new
+      #
+      #   # bad - Report.generate_sumary is not defined, Report.generate_summary is
+      #   Report.generate_sumary
+      #
+      #   # good
+      #   Report.generate_summary
+      #
+      # @example CheckConstants: false
+      #   # good - constant references are not checked
+      #   Services::UserCraetor.new
+      #
+      # @example CheckMethods: false
+      #   # good - method calls are not checked
+      #   Report.generate_sumary
+      #
+      # @example AllowedNames: ['generate_sumary']
+      #   # good - the name is explicitly allowed
+      #   Report.generate_sumary
+      #
+      class NameTypo < Base
+        include ProjectIndexHelp
+
+        CONSTANT_MSG = 'Possible typo: `%<name>s` is not defined in `%<namespace>s`. ' \
+                       'Did you mean `%<suggestion>s`?'
+        METHOD_MSG = 'Possible typo: `%<receiver>s` does not respond to `%<name>s`. ' \
+                     'Did you mean `%<suggestion>s`?'
+
+        METHOD_MEMBER_REGEXP = /#([a-zA-Z_]\w*[?!]?)\(\)\z/.freeze
+        LITERAL_IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!]?/.freeze
+
+        def on_const(node)
+          return unless check?('CheckConstants') && checkable_constant?(node)
+
+          suggestion = constant_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(CONSTANT_MSG, name: node.short_name,
+                                         namespace: node.namespace.const_name,
+                                         suggestion: suggestion)
+          add_offense(node.loc.name, message: message)
+        end
+
+        def on_send(node)
+          return unless check?('CheckMethods')
+          return unless node.receiver&.const_type?
+          return if allowed_name?(node.method_name) || defined_check?(node)
+
+          suggestion = method_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(METHOD_MSG, receiver: node.receiver.const_name,
+                                       name: node.method_name,
+                                       suggestion: suggestion)
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_new_investigation
+          @literal_names = nil
+          super
+        end
+
+        private
+
+        def check?(key)
+          project_index && defined?(DidYouMean::SpellChecker) && cop_config.fetch(key, true)
+        end
+
+        def checkable_constant?(node)
+          node.namespace&.const_type? &&
+            !allowed_name?(node.short_name) &&
+            !definition_identifier?(node) && !defined_check?(node)
+        end
+
+        def allowed_name?(name)
+          cop_config.fetch('AllowedNames', []).include?(name.to_s)
+        end
+
+        # The last segment of a class, module or constant definition is being
+        # defined, not referenced.
+        def definition_identifier?(node)
+          node.parent&.defined_module
+        end
+
+        # `defined?(Foo::Bar)` probes whether a name exists; unknown names
+        # there are deliberate.
+        def defined_check?(node)
+          node.each_ancestor(:defined?).any?
+        end
+
+        def constant_typo_suggestion(node)
+          return nil if literal_names.include?(node.short_name.to_s)
+
+          namespace = resolve_constant_in_index(node.namespace)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+          return nil if namespace.find_member(node.short_name.to_s)
+
+          spell_check(node.short_name, constant_member_names(namespace))
+        rescue StandardError
+          nil
+        end
+
+        # Writers are indexed under the reader's name, so setter calls are
+        # verified and spell-checked through the base name.
+        def method_typo_suggestion(node)
+          setter = setter_call?(node)
+          base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s
+          return nil if literal_names.include?(base)
+
+          declaration = unknown_method_owner(node, base)
+          return nil unless declaration
+
+          suggestion = spell_check(base, method_member_names(declaration))
+          suggestion && setter ? "#{suggestion}=" : suggestion
+        rescue StandardError
+          nil
+        end
+
+        # The receiver's declaration when it resolves in the index, its whole
+        # ancestry is resolved, and the method is not found — nil otherwise.
+        def unknown_method_owner(node, base)
+          declaration = resolve_constant_in_index(node.receiver)
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil if responds_in_index?(declaration, node.method_name.to_s, base)
+          return nil unless fully_resolved_index_ancestry?(declaration)
+
+          declaration
+        end
+
+        def setter_call?(node)
+          node.assignment_method? && !node.operator_method?
+        end
+
+        def responds_in_index?(declaration, name, base)
+          # Instance methods of a module are also callable on the module
+          # itself when exposed with `module_function`.
+          [name, base].uniq.any? do |candidate|
+            member_name = "#{candidate}()"
+            indexed_singleton_member(declaration, member_name) ||
+              declaration.find_member(member_name)
+          end
+        end
+
+        # Names mentioned as symbols or inside string literals in the current
+        # file belong to runtime definitions (`stub_const`, `const_set`,
+        # `define_method`) that the index cannot see.
+        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
+                literal.value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
+              end
+            end
+        end
+
+        def constant_member_names(namespace)
+          namespace.members.filter_map do |member|
+            name = member.name
+            name.split('::').last unless name.include?('#') || name.include?('<')
+          end
+        end
+
+        def method_member_names(declaration)
+          scopes = declaration.ancestors.filter_map { |ancestor| indexed_singleton_of(ancestor) }
+          scopes << declaration
+
+          scopes.flat_map do |scope|
+            scope.members.filter_map { |member| member.name[METHOD_MEMBER_REGEXP, 1] }
+          end
+        end
+
+        def spell_check(name, dictionary)
+          return nil if dictionary.empty?
+
+          DidYouMean::SpellChecker.new(dictionary: dictionary.uniq).correct(name.to_s).first
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,13 @@ module RuboCop
       # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
       # a numeric operation.
       #
+      # @safety
+      #   This cop is unsafe because the autocorrection drops the operands, which
+      #   discards any side effects of evaluating them and can change behavior when
+      #   the result is not actually constant. For example, `x / x` raises
+      #   `ZeroDivisionError` when `x` is `0`, and returns `Float::NAN` (not `1`)
+      #   when `x` is `0.0`; replacing it with `1` silences that.
+      #
       # @example
       #
       #   # bad

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

@@ -119,10 +119,6 @@ module RuboCop
         def regexp_receiver?(send_node)
           send_node.receiver&.regexp_type?
         end
-
-        def nth_ref_receiver?(send_node)
-          send_node.receiver&.nth_ref_type?
-        end
       end
     end
   end

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

@@ -9,6 +9,13 @@ module RuboCop
       # safe navigation operator after a safe navigation operator.
       # This cop checks for the problem outlined above.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it changes the behavior of
+      #   the code: `x&.foo.bar` raises `NoMethodError` when `x` or `x&.foo` is `nil`,
+      #   whereas the corrected `x&.foo&.bar` returns `nil` instead. The autocorrection
+      #   also assumes that extending safe navigation through the chain is intended,
+      #   while removing the first `&.` may be what was intended instead.
+      #
       # @example
       #
       #   # bad

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

@@ -71,7 +71,9 @@ module RuboCop
             send_arg && argument_match?(send_arg, def_arg)
           end
 
-          all_present && !extra_positional_arguments?(arguments, def_node)
+          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
@@ -99,6 +101,40 @@ module RuboCop
           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
+
+        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 Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
@@ -109,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
@@ -120,6 +158,10 @@ module RuboCop
           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

@@ -36,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/unescaped_bracket_in_regexp.rb

@@ -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,19 +53,43 @@ 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)
+
+            # 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?
@@ -78,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/unreachable_code.rb

@@ -52,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
 

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

@@ -0,0 +1,157 @@
+# 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`). Methods defined in classes or modules with
+      # descendants are not checked, since they may be invoked through `super`
+      # or inherited dispatch, and neither are methods whose names are built
+      # dynamically (e.g. `send("do_#{action}")`).
+      #
+      # 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
+      #
+      class UnusedPrivateMethod < Base
+        include ProjectIndexHelp
+
+        MSG = 'Private method `%<method>s` appears to be unused.'
+
+        IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!=]?/.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].to_set.freeze
+
+        class << self
+          # The reference-name set is derived once per index and shared by the
+          # per-file cop instances.
+          def reference_names_cache
+            @reference_names_cache ||= {}.compare_by_identity
+          end
+        end
+
+        def on_new_investigation
+          @literal_names = 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 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 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)
+        end
+
+        def referenced_names
+          self.class.reference_names_cache[project_index] ||=
+            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
+                literal.value.scan(IDENTIFIER_PATTERN) { |token| names << token }
+              end
+            end
+        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/useless_numeric_operation.rb

@@ -36,31 +36,31 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, <<~PATTERN
+          (call ${lvar ivar cvar gvar const (send nil? _)} $_ (int $_))
+        PATTERN
 
         # @!method useless_abbreviated_assignment?(node)
-        def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
+        def_node_matcher :useless_abbreviated_assignment?, <<~PATTERN
+          (op-asgn ${lvasgn ivasgn cvasgn gvasgn casgn} $_ (int $_))
+        PATTERN
 
         def on_send(node)
-          return unless useless_operation?(node)
-
-          variable, operation, number = useless_operation?(node)
+          return unless (receiver, operation, number = useless_operation?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, variable)
+            corrector.replace(node, receiver.source)
           end
         end
         alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless useless_abbreviated_assignment?(node)
-
-          variable, operation, number = useless_abbreviated_assignment?(node)
+          return unless (variable, operation, number = useless_abbreviated_assignment?(node))
           return unless useless?(operation, number)
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{variable}")
+            corrector.replace(node, "#{variable.source} = #{variable.source}")
           end
         end
 

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

@@ -116,6 +116,8 @@ module RuboCop
             # so stop searching once a class/module boundary is crossed without a match.
             return nil if ancestor.type?(:class, :module, :sclass)
           end
+
+          nil
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments