rubocop 1.71.1 → 1.92.1

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.rb

@@ -116,7 +116,7 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :any_block).first
+          ancestor = node.each_ancestor(:kwbegin, :any_def, :any_block).first
           return false unless ancestor
 
           end_line = ancestor.loc.end&.line || ancestor.loc.last_line

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for cases where exceptions unrelated to the numeric constructors `Integer()`,
+      # `Float()`, `BigDecimal()`, `Complex()`, and `Rational()` may be unintentionally swallowed.
+      #
+      # @safety
+      #   The cop is unsafe for autocorrection because unexpected errors occurring in the argument
+      #   passed to numeric constructor (e.g., `Integer()`) can lead to incompatible behavior.
+      #   For example, changing it to `Integer(potential_exception_method_call, exception: false)`
+      #   ensures that exceptions raised by `potential_exception_method_call` are not ignored.
+      #
+      #   [source,ruby]
+      #   ----
+      #   Integer(potential_exception_method_call) rescue nil
+      #   ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Integer(arg) rescue nil
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     Integer(arg)
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   Integer(arg, exception: false)
+      #
+      class SuppressedExceptionInNumberConversion < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        EXPECTED_EXCEPTION_CLASSES = %w[ArgumentError TypeError ::ArgumentError ::TypeError].freeze
+
+        # @!method numeric_constructor_rescue_nil(node)
+        def_node_matcher :numeric_constructor_rescue_nil, <<~PATTERN
+          (rescue
+            $#numeric_method?
+            (resbody nil? nil? (nil)) nil?)
+        PATTERN
+
+        # @!method begin_numeric_constructor_rescue_nil(node)
+        def_node_matcher :begin_numeric_constructor_rescue_nil, <<~PATTERN
+          (kwbegin
+            (rescue
+              $#numeric_method?
+              (resbody $_? nil?
+                {(nil) nil?}) nil?))
+        PATTERN
+
+        # @!method numeric_method?(node)
+        def_node_matcher :numeric_method?, <<~PATTERN
+          {
+            (call #constructor_receiver? {:Integer :BigDecimal :Complex :Rational}
+              _ _?)
+            (call #constructor_receiver? :Float
+              _)
+          }
+        PATTERN
+
+        # @!method constructor_receiver?(node)
+        def_node_matcher :constructor_receiver?, <<~PATTERN
+          {nil? (const {nil? cbase} :Kernel)}
+        PATTERN
+
+        minimum_target_ruby_version 2.6
+
+        # 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)
+
+            node = node.parent
+          else
+            return unless (method = numeric_constructor_rescue_nil(node))
+          end
+
+          # `Integer(arg, exception: false)` already suppresses the conversion error, so there
+          # is nothing unintentionally swallowed; adding another `exception: false` is wrong.
+          return if exception_keyword_argument?(method)
+
+          arguments = method.arguments.map(&:source) << 'exception: false'
+          prefer = "#{method.method_name}(#{arguments.join(', ')})"
+          prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+
+        private
+
+        def exception_keyword_argument?(method)
+          method.arguments.any? do |argument|
+            argument.hash_type? && argument.pairs.any? do |pair|
+              pair.key.sym_type? && pair.key.value == :exception
+            end
+          end
+        end
+
+        def expected_exception_classes_only?(exception_classes)
+          return true unless (arguments = exception_classes.first)
+
+          (arguments.values.map(&:source) - EXPECTED_EXCEPTION_CLASSES).none?
+        end
+      end
+    end
+  end
+end

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

@@ -77,11 +77,28 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          return unless (correction = symbol_conversion_correction(node.receiver))
 
-          if node.receiver.type?(:str, :sym)
-            register_offense(node, correction: node.receiver.value.to_sym.inspect)
-          elsif node.receiver.dstr_type?
-            register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
+          register_offense(node, correction: correction)
+        end
+
+        def symbol_conversion_correction(receiver)
+          if receiver.type?(:str, :sym)
+            receiver.value.to_sym.inspect
+          elsif receiver.dstr_type? && !receiver.heredoc?
+            dstr_correction(receiver)
+          end
+        end
+
+        # Reuse the already-escaped inner source for a plain `"..."` string so embedded
+        # quotes stay escaped. Percent literals (`%{}`, `%Q{}`, ...) and adjacent string
+        # concatenation have multi-character or no delimiters, so slicing the source would
+        # corrupt them; fall back to the node's value there.
+        def dstr_correction(receiver)
+          if receiver.loc.begin&.source == '"'
+            ":\"#{receiver.source[1..-2]}\""
+          else
+            ":\"#{receiver.value.to_sym}\""
           end
         end
 
@@ -168,6 +185,7 @@ module RuboCop
             ignore_node(key)
 
             next if requires_quotes?(key)
+            next if key.parent.value_omission?
             next if properly_quoted?(key.source, %("#{key.value}"))
 
             correction = %("#{key.value}")

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

@@ -26,7 +26,31 @@ module RuboCop
                       "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
                         'configure using `TargetRubyVersion` parameter, under `AllCops`)'
                     end
-          add_offense(diagnostic.location, message: message, severity: diagnostic.level)
+          location = diagnostic_location(diagnostic.location)
+          add_offense(location, message: message, severity: diagnostic.level)
+        end
+
+        # Expand zero-length diagnostic ranges so that editors and formatters
+        # can display them. This typically occurs when the parser reports
+        # `unexpected token $end` at EOF.
+        def diagnostic_location(location)
+          return location if location.size.positive?
+
+          source_buffer = location.source_buffer
+          if location.end_pos < source_buffer.source.size
+            location.resize(1)
+          elsif location.begin_pos.positive?
+            location.adjust(begin_pos: -1)
+          else
+            location
+          end
+        end
+
+        # Override to skip multiline_ranges check which requires AST.
+        # Syntax errors mean the AST is nil, so we go directly to
+        # the EOL comment insertion path.
+        def disable_offense(offense_range)
+          disable_offense_with_eol_or_surround_comment(offense_range)
         end
 
         def add_offense_from_error(error)

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

@@ -45,7 +45,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|
@@ -61,7 +61,7 @@ module RuboCop
         def arguments_match?(arguments, def_node)
           index = 0
 
-          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+          all_present = def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
             send_arg = arguments[index]
             case def_arg.type
             when :arg, :restarg, :optarg
@@ -70,9 +70,72 @@ module RuboCop
 
             send_arg && argument_match?(send_arg, def_arg)
           end
+
+          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
+        # positional arguments than the method accepts raises `ArgumentError` at runtime.
+        def extra_positional_arguments?(arguments, def_node)
+          return false if variadic_parameters?(def_node) || expandable_arguments?(arguments)
+
+          positional_arguments(arguments).size > positional_parameters(def_node).size
+        end
+
+        def variadic_parameters?(def_node)
+          def_node.arguments.any? { |arg| arg.type?(:restarg, :forward_arg) }
+        end
+
+        # A splat or argument forwarding on the call side can expand to any arity.
+        def expandable_arguments?(arguments)
+          arguments.any? { |arg| arg.type?(:splat, :forwarded_args, :forwarded_restarg) }
+        end
+
+        def positional_arguments(arguments)
+          arguments.reject { |arg| arg.type?(:hash, :kwsplat, :block_pass, :forwarded_kwrestarg) }
+        end
+
+        def positional_parameters(def_node)
+          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
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        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]
 
@@ -82,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
@@ -92,7 +157,10 @@ 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?
+        end
       end
     end
   end

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

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base
@@ -40,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/top_level_return_with_argument.rb

@@ -40,7 +40,7 @@ module RuboCop
         # top-level return node's ancestors should not be of block, def, or
         # defs type.
         def top_level_return?(return_node)
-          return_node.each_ancestor(:block, :def, :defs).none?
+          return_node.each_ancestor(:any_block, :any_def).none?
         end
       end
     end

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

@@ -32,9 +32,13 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
-          return unless node.attribute_accessor? && node.last_argument.def_type?
+          return unless node.attribute_accessor? && node.last_argument.any_def_type?
+          # A lone `def` argument (e.g. `attr_reader def foo; end`) has no preceding
+          # attribute, so there is no trailing comma to flag.
+          return unless node.arguments.size > 1
 
           trailing_comma = trailing_comma_range(node)