rubocop 1.53.0 → 1.90.0

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

@@ -1,17 +1,29 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
       # Checks that there is an `# rubocop:enable ...` statement
       # after a `# rubocop:disable ...` statement. This will prevent leaving
-      # cop disables on wide ranges of code, that latter contributors to
+      # cop disables on wide ranges of code, that later contributors to
       # a file wouldn't be aware of.
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: .inf
+      # You can set `MaxRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaxRangeSize: .inf (default)
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -25,9 +37,7 @@ module RuboCop
       #   x= 0
       #   # EOF
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: 2
+      # @example MaxRangeSize: 2
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -45,17 +55,16 @@ module RuboCop
       class MissingCopEnableDirective < Base
         include RangeHelp
 
-        MSG = 'Re-enable %<cop>s %<type>s with `# rubocop:enable` after disabling it.'
+        MSG = 'Re-enable %<cop>s %<type>s with `%<directive>s` after disabling it.'
         MSG_BOUND = 'Re-enable %<cop>s %<type>s within %<max_range>s lines after disabling it.'
 
         def on_new_investigation
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, (0..0))
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 
@@ -63,7 +72,12 @@ module RuboCop
 
         def each_missing_enable
           processed_source.disabled_line_ranges.each do |cop, line_ranges|
-            line_ranges.each { |line_range| yield cop, line_range }
+            line_ranges.each do |line_range|
+              # A `disable-next` scope closes itself with its statement.
+              next if line_range.respond_to?(:directive) && line_range.directive.disable_next?
+
+              yield cop, line_range
+            end
           end
         end
 
@@ -71,31 +85,40 @@ module RuboCop
           # This has to remain a strict inequality to handle
           # the case when max_range is Float::INFINITY
           return true if line_range.max - line_range.min < max_range + 2
+          # A name that is not registered as written (e.g. a wrongly-namespaced
+          # cop) suppresses nothing; `Lint/RedundantCopDisableDirective` reports
+          # it, so demanding its re-enablement would only add noise.
+          return true unless Registry.global.names.include?(cop)
+
+          expected_open_range?(cop, line_range)
+        end
+
+        def expected_open_range?(cop, line_range)
           # This cop is disabled in the config, it is not expected to be re-enabled
           return true if line_range.min == CommentConfig::CONFIG_DISABLED_LINE_RANGE_MIN
 
-          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name cop
-          if cop_class &&
+          cop_class = RuboCop::Cop::Registry.global.find_by_cop_name(cop)
+          !!(cop_class &&
              !processed_source.registry.enabled?(cop_class, config) &&
-             line_range.max == Float::INFINITY
-            return true
-          end
-
-          false
+             line_range.max == Float::INFINITY)
         end
 
         def max_range
-          @max_range ||= cop_config['MaximumRangeSize']
+          @max_range ||= cop_config['MaxRangeSize']
         end
 
         def message(cop, comment, type = 'cop')
+          directive = DirectiveComment.new(comment)
           if department_enabled?(cop, comment)
             type = 'department'
             cop = cop.split('/').first
           end
 
           if max_range == Float::INFINITY
-            format(MSG, cop: cop, type: type)
+            # A range opened by `rubocop:push` is closed by `rubocop:pop`,
+            # not by `rubocop:enable`.
+            enabling_directive = directive.push? ? '# rubocop:pop' : '# rubocop:enable'
+            format(MSG, cop: cop, type: type, directive: enabling_directive)
           else
             format(MSG_BOUND, cop: cop, type: type, max_range: max_range)
           end
@@ -108,4 +131,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

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

@@ -21,6 +21,13 @@ module RuboCop
       # `AllowedParentClasses` option to specify which classes should be allowed
       # *in addition to* `Object` and `BasicObject`.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the constructor check additionally consults the project-wide index: if the
+      # class' entire ancestry is resolvable and no ancestor defines `initialize`,
+      # no offense is registered, since `super` would only reach the no-op
+      # `Object#initialize`. Classes whose ancestry contains an unresolvable
+      # superclass or mixin (e.g. one defined in a gem) are still reported.
+      #
       # @example
       #   # bad
       #   class Employee < Person
@@ -83,6 +90,8 @@ module RuboCop
       #   end
       #
       class MissingSuper < Base
+        include ProjectIndexHelp
+
         CONSTRUCTOR_MSG = 'Call `super` to initialize state of the parent class.'
         CALLBACK_MSG    = 'Call `super` to invoke callback defined in the parent class.'
 
@@ -97,7 +106,7 @@ module RuboCop
 
         # @!method class_new_block(node)
         def_node_matcher :class_new_block, <<~RUBY
-          ({block numblock}
+          (any_block
             (send
               (const {nil? cbase} :Class) :new $_) ...)
         RUBY
@@ -135,12 +144,13 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          if (block_node = node.each_ancestor(:block, :numblock).first)
+          if (block_node = node.each_ancestor(:any_block).first)
             return false unless (super_class = class_new_block(block_node))
 
             !allowed_class?(super_class)
           elsif (class_node = node.each_ancestor(:class).first)
-            class_node.parent_class && !allowed_class?(class_node.parent_class)
+            class_node.parent_class && !allowed_class?(class_node.parent_class) &&
+              !index_verified_stateless_ancestry?(class_node)
           else
             false
           end
@@ -153,6 +163,26 @@ module RuboCop
         def allowed_classes
           @allowed_classes ||= STATELESS_CLASSES + cop_config.fetch('AllowedParentClasses', [])
         end
+
+        # With the project index, the offense is skipped when the class' whole ancestry
+        # is resolvable and none of the inherited ancestors defines `initialize` —
+        # `super` would only reach the no-op `Object#initialize`. An unresolvable
+        # superclass or mixin anywhere in the chain (e.g. a class from a gem) means
+        # the ancestry cannot be verified and the offense is kept.
+        def index_verified_stateless_ancestry?(class_node)
+          return false unless project_index
+
+          declaration = resolve_constant_in_index(class_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Class)
+
+          ancestors = declaration.ancestors.to_a
+          inherited = ancestors.reject { |ancestor| ancestor.name == declaration.name }
+          return false if inherited.any? { |ancestor| ancestor.member('initialize()') }
+
+          # `extend` affects the singleton class and cannot introduce an
+          # inherited `initialize`, so unresolved extends are tolerated.
+          fully_resolved_index_ancestry?(declaration, ignore_extend: true)
+        end
       end
     end
   end

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

@@ -8,7 +8,7 @@ module RuboCop
       # Offenses are registered for regexp character classes like `/[A-z]/`
       # as well as range objects like `('A'..'z')`.
       #
-      # NOTE: Range objects cannot be autocorrected.
+      # NOTE: `Range` objects cannot be autocorrected.
       #
       # @safety
       #   The cop autocorrects regexp character classes
@@ -36,19 +36,18 @@ module RuboCop
 
         def on_irange(node)
           return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
 
-          range_start, range_end = node.children
-
-          return if range_start.nil? || range_end.nil?
-
-          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
         end
         alias on_erange on_irange
 
         def on_regexp(node)
           each_unsafe_regexp_range(node) do |loc|
+            next unless (replacement = regexp_range(loc.source))
+
             add_offense(loc) do |corrector|
-              corrector.replace(loc, rewrite_regexp_range(loc.source))
+              corrector.replace(loc, replacement)
             end
           end
         end
@@ -80,10 +79,12 @@ module RuboCop
         end
 
         def range_pairs(expr)
-          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
         end
 
         def unsafe_range?(range_start, range_end)
+          return false if range_start.length != 1 || range_end.length != 1
+
           range_for(range_start) != range_for(range_end)
         end
 
@@ -93,14 +94,17 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type == :escape
+            bound&.type != :literal
           end
         end
 
-        def rewrite_regexp_range(source)
+        def regexp_range(source)
           open, close = source.split('-')
-          first = [open, range_for(open).end]
-          second = [range_for(close).begin, close]
+          return unless (open_range = range_for(open))
+          return unless (close_range = range_for(close))
+
+          first = [open, open_range.end]
+          second = [close_range.begin, close]
           "#{first.uniq.join('-')}#{second.uniq.join('-')}"
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Do not mix named captures and numbered captures in a Regexp literal
+      # Do not mix named captures and numbered captures in a `Regexp` literal
       # because numbered capture is ignored if they're mixed.
       # Replace numbered captures with non-capturing groupings or
       # named captures.

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # In math and Python, we can use `x < y < z` style comparison to compare
-      # multiple value. However, we can't use the comparison in Ruby. However,
-      # the comparison is not syntax error. This cop checks the bad usage of
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
       # comparison operators.
       #
       # @example

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

@@ -0,0 +1,270 @@
+# 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.
+      #
+      # For the same reason, a namespace whose root segment names a gem in the
+      # bundle (`Flipper` for the `flipper` gem) is left alone: a project that
+      # reopens it (`module Flipper; module Adapters; ...`) makes it resolve in
+      # the index, while the members the gem itself defines stay invisible and
+      # would look like typos. Enabling `AllCops/ProjectIndexIncludesGems`
+      # indexes those sources and restores the check.
+      #
+      # 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)
+          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)
+          return nil unless complete_index_members?(namespace)
+          return nil if literal_names.include?(node.short_name.to_s)
+
+          spell_check(node.short_name, constant_member_names(namespace))
+        rescue StandardError
+          nil
+        end
+
+        # Whether the index can be trusted to list everything the namespace
+        # defines. A name missing from an incomplete member list is not
+        # evidence of a typo, so both gaps have to be ruled out first:
+        # an ancestor that does not resolve may contribute the name, and so
+        # may a gem that reopens the namespace.
+        def complete_index_members?(declaration)
+          fully_resolved_index_ancestry?(declaration) && !gem_owned_namespace?(declaration)
+        end
+
+        # Whether the namespace's root segment names a gem in the bundle,
+        # which is then free to define members the index never sees: gem
+        # sources are only indexed when `AllCops/ProjectIndexIncludesGems`
+        # is enabled. A project that reopens such a namespace to add its own
+        # members (`module Flipper; module Adapters; ...`) makes it resolve
+        # in the index while most of what it holds stays invisible.
+        def gem_owned_namespace?(declaration)
+          return false if config.for_all_cops['ProjectIndexIncludesGems']
+
+          root = declaration.name.to_s.split('::').first.to_s
+          bundled_gem_namespaces.include?(root.downcase)
+        end
+
+        # Gem names normalized towards the constant they conventionally
+        # provide: `flipper` for `Flipper`, `activerecord` for `ActiveRecord`.
+        def bundled_gem_namespaces
+          @bundled_gem_namespaces ||= bundled_gem_names.to_set { |name| name.delete('-_').downcase }
+        end
+
+        # The bundle's gems except those sourced from a local path, whose code
+        # lives in the project and is indexed like the rest of it — among them
+        # the project's own gem, which its lockfile lists in the `PATH` section.
+        def bundled_gem_names
+          (config.gem_versions_in_target || {}).keys - (config.path_sourced_gems_in_target || [])
+        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
+
+          declaration = unknown_method_owner(node, base)
+          return nil unless declaration
+          return nil if literal_names.include?(base)
+
+          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, everything
+        # it can inherit or be reopened with is visible there, 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)
+          return nil if gem_owned_namespace?(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
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                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/nested_method_definition.rb

@@ -17,8 +17,6 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def foo
@@ -26,8 +24,6 @@ module RuboCop
       #     bar.call
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   # `class_eval`, `instance_eval`, `module_eval`, `class_exec`, `instance_exec`, and
@@ -47,8 +43,6 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   def foo
@@ -101,14 +95,14 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
-          return if node.defs_type? && subject.lvar_type?
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
 
-          def_ancestor = node.each_ancestor(:def, :defs).first
+          def_ancestor = node.each_ancestor(:any_def).first
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -123,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 
@@ -131,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end