rubocop 1.88.2 → 1.90.0

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

@@ -30,21 +30,55 @@ module RuboCop
       #   foo = "1"
       #   # rubocop:enable all
       #   baz
+      #
+      #   # bad
+      #   foo = 1
+      #   # rubocop:pop
+      #
+      #   # good
+      #   # rubocop:push -Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:pop
       class RedundantCopEnableDirective < Base
         include RangeHelp
         include SurroundingSpace
         extend AutoCorrector
 
         MSG = 'Unnecessary enabling of %<cop>s.'
+        MSG_ORPHAN_POP = 'Unnecessary `rubocop:pop` without a matching `rubocop:push`.'
 
         def on_new_investigation
-          return if processed_source.blank? || !processed_source.raw_source.include?('enable')
+          return if processed_source.blank?
 
+          source = processed_source.raw_source
+          check_extra_enables if source.include?('enable')
+          check_orphan_pops if source.include?('pop')
+        end
+
+        private
+
+        def check_extra_enables
           offenses = processed_source.comment_config.extra_enabled_comments
           offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
         end
 
-        private
+        def check_orphan_pops
+          push_depth = 0
+          processed_source.comments.each do |comment|
+            directive = DirectiveComment.new(comment)
+            if directive.push?
+              push_depth += 1
+            elsif directive.pop?
+              push_depth.zero? ? register_orphan_pop(directive) : push_depth -= 1
+            end
+          end
+        end
+
+        def register_orphan_pop(directive)
+          add_offense(directive.range, message: MSG_ORPHAN_POP) do |corrector|
+            corrector.remove(range_with_surrounding_space(directive.range, side: :right))
+          end
+        end
 
         def register_offense(comment, cop_names)
           directive = DirectiveComment.new(comment)
@@ -55,15 +89,21 @@ module RuboCop
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              if directive.match?(cop_names)
-                corrector.remove(range_with_surrounding_space(directive.range, side: :right))
-              else
-                corrector.remove(range_with_comma(comment, name))
-              end
+              corrector.remove(removal_range(directive, comment, cop_names, name))
             end
           end
         end
 
+        # When every cop on the directive is redundant the whole comment goes, `--` reason
+        # included; otherwise just the one cop is spliced out of the list.
+        def removal_range(directive, comment, cop_names, name)
+          if directive.match?(cop_names)
+            range_with_surrounding_space(directive.range_with_reason, side: :right)
+          else
+            range_with_comma(comment, name)
+          end
+        end
+
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

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

@@ -63,7 +63,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_feature?(feature_name)
           feature_name == 'enumerator' ||
             (target_ruby_version >= 2.1 && feature_name == 'thread') ||
@@ -73,7 +73,6 @@ module RuboCop
             (target_ruby_version >= 3.2 && feature_name == 'set') ||
             (target_ruby_version >= 4.0 && feature_name == 'pathname')
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -208,7 +208,7 @@ module RuboCop
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -221,7 +221,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -139,7 +139,7 @@ module RuboCop
           grandparent.array_type? && grandparent.children.size > 1
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def replacement_range_and_content(node)
           variable = node.children.first
           expression = node.source_range
@@ -157,7 +157,6 @@ module RuboCop
             [node.loc.operator, '']
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def array_splat?(node)
           node.children.first.array_type?

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

@@ -192,7 +192,7 @@ module RuboCop
           (hash (pair (sym :exception) false))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
           return if node.arguments.any? || hash_or_set_with_block?(node)
 
@@ -208,7 +208,6 @@ module RuboCop
             corrector.remove(node.loc.dot.join(node.loc.end || node.loc.selector))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         private

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

@@ -33,7 +33,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_block(node)
           return unless node.receiver
           return if node.method?(:with_index) && !node.receiver.receiver
@@ -50,7 +50,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
         alias on_itblock on_block

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
@@ -38,7 +45,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless require_safe_navigation?(node)
 
@@ -56,7 +63,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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

@@ -85,7 +85,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_consistent_parts(grouped_operands)
           csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
@@ -99,7 +99,6 @@ module RuboCop
             ['.', csend_in_or]
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def already_appropriate_call?(operand, dot_op)
           return true if operand.safe_navigation? && dot_op == '&.'
@@ -126,7 +125,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def most_left_indices(grouped_operands)
           indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
 
@@ -139,7 +138,6 @@ module RuboCop
 
           indices.values
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def operand_in_and?(node)
           return true if node.parent.and_type?

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `super` calls with explicit arguments that pass the wrong
+      # number of positional arguments to the overridden implementation, using
+      # the project index.
+      #
+      # 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.
+      #
+      # Only `super` inside a plain instance method defined directly in a class
+      # body is considered, and only when the enclosing class resolves in the
+      # index and its entire ancestry is resolved, so a superclass method coming
+      # from a gem, the standard library, or a dynamic definition never produces
+      # an offense. The overridden implementation is the first ancestor after
+      # the enclosing class in the index's method resolution order that defines
+      # the method; when it is not a plain method definition (an `attr_*` or an
+      # alias) or its definitions disagree on arity, the call is not checked.
+      # Calls that forward arguments (`*`, `**`, `...`) are skipped, and bare
+      # `super` (which forwards the current method's parameters) is not checked.
+      # Methods the index attributes to `Object`, `Kernel`, or `BasicObject`
+      # are never used as the overridden implementation, since a `def` inside
+      # a block at the top level (`Struct.new do ... end`) is indexed under
+      # `Object` even though it defines a method somewhere else entirely.
+      #
+      # @example
+      #   # Given the project defines:
+      #   #   class Base
+      #   #     def initialize(name, size); end
+      #   #   end
+      #
+      #   # bad
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Widget < Base
+      #     def initialize(name)
+      #       super(name, 0)
+      #     end
+      #   end
+      #
+      class SuperArgumentMismatch < Base
+        include ProjectIndexHelp
+        include IndexedMethodArity
+
+        MSG = 'Wrong number of arguments to `super` ' \
+              '(given %<given>d, expected %<expected>s for `%<parent>s#%<method>s`).'
+
+        # Blocks that change what method (or scope) `super` refers to, or in
+        # which `super` is not statically resolvable.
+        CONTEXT_CHANGING_BLOCKS = %i[
+          define_method define_singleton_method class_eval class_exec
+          module_eval module_exec instance_eval instance_exec refine
+        ].freeze
+
+        # Methods the index attributes to the root namespaces are not
+        # trustworthy super targets: a `def` inside a block at the top level
+        # (`Struct.new do ... end`, `Class.new do ... end`) is indexed under
+        # `Object` even though it defines a method somewhere else entirely.
+        BUILTIN_ROOTS = %w[Object Kernel BasicObject].freeze
+
+        def on_super(node)
+          return unless project_index
+
+          def_node = enclosing_instance_method(node)
+          return unless def_node
+
+          shape, parent = resolved_super_shape(def_node)
+          return unless shape
+
+          min, max, has_keywords = shape
+          given = positional_argument_count(node, has_keywords)
+          return if given.nil? || arity_satisfied?(given, min, max)
+
+          add_offense(node.loc.keyword,
+                      message: message(def_node.method_name, parent, given, min, max))
+        end
+
+        private
+
+        def message(method_name, parent, given, min, max)
+          format(MSG, given: given, expected: expected_range(min, max),
+                      parent: parent.name, method: method_name)
+        end
+
+        # The `def` node whose method the `super` call re-dispatches, or nil
+        # when the context is not statically known: `super` inside a
+        # singleton method, inside `define_method` or an eval/refine block,
+        # or outside any method.
+        def enclosing_instance_method(node)
+          node.each_ancestor(:any_def, :any_block, :sclass).each do |ancestor|
+            case ancestor.type
+            when :def then return ancestor
+            when :defs, :sclass then return nil
+            else
+              return nil if CONTEXT_CHANGING_BLOCKS.include?(ancestor.method_name)
+            end
+          end
+
+          nil
+        end
+
+        # `[[min, max, has_keywords], parent]` for the implementation `super`
+        # dispatches to, or nil when the enclosing class or the overridden
+        # method is not statically known.
+        def resolved_super_shape(def_node)
+          declaration = enclosing_class_declaration(def_node)
+          return nil unless declaration
+          return nil unless fully_resolved_index_ancestry?(declaration, ignore_extend: true)
+
+          super_method_shape(declaration, def_node.method_name)
+        rescue StandardError
+          nil
+        end
+
+        # The index declaration of the class whose body directly contains
+        # `def_node`, or nil when the method is not defined directly in a
+        # class body (module methods are excluded because their `super`
+        # target depends on where the module is mixed in) or the class does
+        # not resolve in the index.
+        def enclosing_class_declaration(def_node)
+          class_node = def_node.each_ancestor(:class, :module, :sclass, :any_block).first
+          return nil unless class_node&.class_type?
+
+          declaration = project_index[lexical_nesting_of(def_node).join('::')]
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil unless declared_at?(declaration, class_node)
+
+          declaration
+        end
+
+        # Whether one of the declaration's definitions is the given class
+        # node, anchoring the name-based lookup to the source being
+        # inspected (a qualified identifier like `class Foo::Bar` can
+        # resolve to a namespace other than the joined nesting names).
+        def declared_at?(declaration, class_node)
+          declaration.definitions.any? do |definition|
+            location = definition.location
+            location.uri.start_with?(FILE_URI_PREFIX) &&
+              location.to_display.start_line == class_node.first_line &&
+              same_file?(location.to_file_path, processed_source.file_path)
+          end
+        end
+
+        # The shape of the first implementation of `method_name` after the
+        # enclosing class in the index's method resolution order, or nil
+        # when no indexed ancestor defines it (e.g. it comes from a gem or
+        # the standard library, which are not indexed).
+        def super_method_shape(declaration, method_name)
+          ancestors = declaration.ancestors.to_a
+          position = ancestors.index { |ancestor| ancestor.name == declaration.name }
+          return nil unless position
+
+          ancestors.drop(position + 1).each do |ancestor|
+            return nil if BUILTIN_ROOTS.include?(ancestor.name)
+
+            member = ancestor.member("#{method_name}()")
+            next unless member
+
+            # The first definer along the chain is the receiving
+            # implementation; when its shape is unknown there is nothing
+            # further to check.
+            shape = indexed_member_shape(member)
+            return shape && [shape, ancestor]
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -78,7 +78,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_rescue(node)
           if (method, exception_classes = begin_numeric_constructor_rescue_nil(node.parent))
             return unless expected_exception_classes_only?(exception_classes)
@@ -100,7 +100,6 @@ module RuboCop
             corrector.replace(node, prefer)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

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,7 +101,41 @@ module RuboCop
           def_node.arguments.select { |arg| arg.type?(:arg, :optarg) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        # 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-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -121,7 +157,6 @@ module RuboCop
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def keyword_hash_argument?(send_arg)
           send_arg.hash_type? && !send_arg.braces?

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

@@ -83,7 +83,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -102,7 +102,6 @@ module RuboCop
             false
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def check_if(node)
           if_branch = node.if_branch