rubocop 1.71.1 → 1.88.2

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

@@ -20,6 +20,15 @@ module RuboCop
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # The `InferNonNilReceiver` option specifies whether to look into previous code
+      # paths to infer if the receiver can't be nil. This check is unsafe because the receiver
+      # can be redefined between the safe navigation call and previous regular method call.
+      # It does the inference only in the current scope, e.g. within the same method definition etc.
+      #
+      # The `AdditionalNilMethods` option specifies additional custom methods which are
+      # defined on `NilClass`. When `InferNonNilReceiver` is set, they are used to determine
+      # whether the receiver can be nil.
+      #
       # @safety
       #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
@@ -33,12 +42,42 @@ module RuboCop
       #   CamelCaseConst.do_something
       #
       #   # bad
+      #   foo.to_s&.strip
+      #   foo.to_i&.zero?
+      #   foo.to_f&.zero?
+      #   foo.to_a&.size
+      #   foo.to_h&.size
+      #
+      #   # good
+      #   foo.to_s.strip
+      #   foo.to_i.zero?
+      #   foo.to_f.zero?
+      #   foo.to_a.size
+      #   foo.to_h.size
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
       #   do_something if attrs.respond_to?(:[])
       #
       #   # bad
+      #   foo&.bar ? foo&.bar.baz : qux
+      #
+      #   # good
+      #   foo&.bar ? foo.bar.baz : qux
+      #
+      #   # bad
+      #   if foo&.bar
+      #     foo&.bar.baz
+      #   end
+      #
+      #   # good
+      #   if foo&.bar
+      #     foo.bar.baz
+      #   end
+      #
+      #   # bad
       #   while node&.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -48,8 +87,9 @@ module RuboCop
       #     node = node.parent
       #   end
       #
-      #   # good - without `&.` this will always return `true`
+      #   # good - without `&.` this changes the return value for `nil`
       #   foo&.respond_to?(:to_a)
+      #   foo&.respond_to?(:class)
       #
       #   # bad - for `nil`s conversion methods return default values for the type
       #   foo&.to_h || {}
@@ -81,27 +121,69 @@ module RuboCop
       #   do_something if attrs.nil_safe_method(:[])
       #   do_something if attrs&.not_nil_safe_method(:[])
       #
+      # @example InferNonNilReceiver: false (default)
+      #   # good
+      #   foo.bar
+      #   foo&.baz
+      #
+      # @example InferNonNilReceiver: true
+      #   # bad
+      #   foo.bar
+      #   foo&.baz # would raise on previous line if `foo` is nil
+      #
+      #   # good
+      #   foo.bar
+      #   foo.baz
+      #
+      #   # bad
+      #   if foo.condition?
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   if foo.condition?
+      #     foo.bar
+      #   end
+      #
+      #   # good (different scopes)
+      #   def method1
+      #     foo.bar
+      #   end
+      #
+      #   def method2
+      #     foo&.bar
+      #   end
+      #
+      # @example AdditionalNilMethods: [present?]
+      #   # good
+      #   foo.present?
+      #   foo&.bar
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected, use `.` instead.'
         MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+        MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
+                      'previous code/method invocations).'
 
-        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+        NIL_METHODS = nil.methods.to_set.freeze
 
         SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
 
-        # @!method respond_to_nil_specific_method?(node)
-        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
-          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
+
+        # @!method respond_to_nil_method?(node)
+        def_node_matcher :respond_to_nil_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_METHODS))
         PATTERN
 
         # @!method conversion_with_default?(node)
         def_node_matcher :conversion_with_default?, <<~PATTERN
           {
             (or $(csend _ :to_h) (hash))
-            (or (block $(csend _ :to_h) ...) (hash))
+            (or (any_block $(csend _ :to_h) ...) (hash))
             (or $(csend _ :to_a) (array))
             (or $(csend _ :to_i) (int 0))
             (or $(csend _ :to_f) (float 0.0))
@@ -109,17 +191,24 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
-          unless assume_receiver_instance_exists?(node.receiver)
-            return unless check?(node) && allowed_method?(node.method_name)
-            return if respond_to_nil_specific_method?(node)
+          range = node.loc.dot
+
+          if infer_non_nil_receiver?
+            checker = Lint::Utils::NilReceiverChecker.new(node.receiver, additional_nil_methods)
+
+            if checker.cant_be_nil?
+              add_offense(range, message: MSG_NON_NIL) { |corrector| corrector.replace(range, '.') }
+              return
+            end
           end
 
-          range = node.loc.dot
+          return if guarded_by_nil_receiver?(node)
+
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -136,13 +225,38 @@ module RuboCop
 
         private
 
+        # Returns true when the `&.` is meaningful because the receiver may actually be nil.
+        def guarded_by_nil_receiver?(node)
+          return false if assume_receiver_instance_exists?(node.receiver)
+
+          guaranteed_instance = guaranteed_instance?(node.receiver)
+          return true if !guaranteed_instance && !check?(node)
+
+          # `nil.respond_to?(<nil method>)` is `true`, so `&.` is meaningful when the receiver
+          # may be nil. A guaranteed instance can never be nil, so `&.` is still redundant there.
+          respond_to_nil_method?(node) && !guaranteed_instance
+        end
+
         def assume_receiver_instance_exists?(receiver)
           return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 
           receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
+        def guaranteed_instance?(node)
+          receiver = if node.any_block_type?
+                       node.send_node
+                     else
+                       node
+                     end
+          return false unless receiver.send_type?
+
+          GUARANTEED_INSTANCE_METHODS.include?(receiver.method_name)
+        end
+
         def check?(node)
+          return false unless allowed_method?(node.method_name)
+
           parent = node.parent
           return false unless parent
 
@@ -154,6 +268,15 @@ module RuboCop
         def condition?(parent, node)
           (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
         end
+
+        def infer_non_nil_receiver?
+          cop_config['InferNonNilReceiver']
+        end
+
+        def additional_nil_methods
+          @additional_nil_methods ||=
+            Array(cop_config.fetch('AdditionalNilMethods', []).map(&:to_sym))
+        end
       end
     end
   end

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

@@ -77,7 +77,7 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'
         PERCENT_I = '%i'
         PERCENT_CAPITAL_I = '%I'
-        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
         # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
@@ -122,6 +122,10 @@ module RuboCop
 
               grandparent = node.parent.parent
               return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+            # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
+            # removing the splat would produce invalid or semantically different code.
+            elsif expanded_item.array_type? && expanded_item.children.empty?
+              return
             end
 
             yield
@@ -144,7 +148,9 @@ module RuboCop
             expression = node.parent.source_range if node.parent.array_type?
             [expression, variable.source]
           elsif !variable.array_type?
-            [expression, "[#{variable.source}]"]
+            replacement = variable.source
+            replacement = "[#{replacement}]" if wrap_in_brackets?(node)
+            [expression, replacement]
           elsif redundant_brackets?(node)
             [expression, remove_brackets(variable)]
           else
@@ -176,6 +182,10 @@ module RuboCop
             grandparent&.resbody_type?
         end
 
+        def wrap_in_brackets?(node)
+          node.parent.array_type? && !node.parent.bracketed?
+        end
+
         def remove_brackets(array)
           array_start = array.loc.begin.source
           elements = *array

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `to_d`, `to_r`, `to_c`,
+      # `to_a`, `to_h`, and `to_set`.
+      #
+      # When one of these methods is called on an object of the same type, that object
+      # is returned, making the call unnecessary. The cop detects conversion methods called
+      # on object literals, class constructors, class `[]` methods, and the `Kernel` methods
+      # `String()`, `Integer()`, `Float()`, BigDecimal(), `Rational()`, `Complex()`, and `Array()`.
+      #
+      # Specifically, these cases are detected for each conversion method:
+      #
+      # * `to_s` when called on a string literal, interpolated string, heredoc,
+      #   or with `String.new` or `String()`.
+      # * `to_sym` when called on a symbol literal or interpolated symbol.
+      # * `to_i` when called on an integer literal or with `Integer()`.
+      # * `to_f` when called on a float literal or with `Float()`.
+      # * `to_d` when called with `BigDecimal()`.
+      # * `to_r` when called on a rational literal or with `Rational()`.
+      # * `to_c` when called on a complex literal or with `Complex()`.
+      # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
+      # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
+      # * `to_set` when called on `Set.new` or `Set[]`.
+      #
+      # In all cases, chaining one of the same `to_*` conversion methods listed above is redundant.
+      #
+      # The cop can also register an offense for chaining conversion methods on methods that are
+      # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and
+      # `foo.to_json.to_s`).
+      #
+      # @example
+      #   # bad
+      #   "text".to_s
+      #   :sym.to_sym
+      #   42.to_i
+      #   8.5.to_f
+      #   12r.to_r
+      #   1i.to_c
+      #   [].to_a
+      #   {}.to_h
+      #   Set.new.to_set
+      #
+      #   # good
+      #   "text"
+      #   :sym
+      #   42
+      #   8.5
+      #   12r
+      #   1i
+      #   []
+      #   {}
+      #   Set.new
+      #
+      #   # bad
+      #   Integer(var).to_i
+      #
+      #   # good
+      #   Integer(var)
+      #
+      #   # good - chaining to a type constructor with exceptions suppressed
+      #   # in this case, `Integer()` could return `nil`
+      #   Integer(var, exception: false).to_i
+      #
+      #   # bad
+      #   BigDecimal(var).to_d
+      #
+      #   # good
+      #   BigDecimal(var)
+      #
+      #   # bad - chaining the same conversion
+      #   foo.to_s.to_s
+      #
+      #   # good
+      #   foo.to_s
+      #
+      #   # bad - chaining a conversion to a method that is expected to return the same type
+      #   foo.inspect.to_s
+      #   foo.to_json.to_s
+      #
+      #   # good
+      #   foo.inspect
+      #   foo.to_json
+      #
+      class RedundantTypeConversion < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant `%<method>s` detected.'
+
+        # Maps conversion methods to the node types for the literals of that type
+        LITERAL_NODE_TYPES = {
+          to_s: %i[str dstr],
+          to_sym: %i[sym dsym],
+          to_i: %i[int],
+          to_f: %i[float],
+          to_r: %i[rational],
+          to_c: %i[complex],
+          to_a: %i[array],
+          to_h: %i[hash],
+          to_set: [] # sets don't have a literal or node type
+        }.freeze
+
+        # Maps each conversion method to the pattern matcher for that type's constructors
+        # Not every type has a constructor, for instance Symbol.
+        CONSTRUCTOR_MAPPING = {
+          to_s: 'string_constructor?',
+          to_i: 'integer_constructor?',
+          to_f: 'float_constructor?',
+          to_d: 'bigdecimal_constructor?',
+          to_r: 'rational_constructor?',
+          to_c: 'complex_constructor?',
+          to_a: 'array_constructor?',
+          to_h: 'hash_constructor?',
+          to_set: 'set_constructor?'
+        }.freeze
+
+        # Methods that already are expected to return a given type, which makes a further
+        # conversion redundant.
+        TYPED_METHODS = { to_s: %i[inspect to_json] }.freeze
+
+        CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
+        RESTRICT_ON_SEND = CONVERSION_METHODS + [:to_d]
+
+        private_constant :LITERAL_NODE_TYPES, :CONSTRUCTOR_MAPPING
+
+        # @!method type_constructor?(node, type_symbol)
+        def_node_matcher :type_constructor?, <<~PATTERN
+          (send {nil? (const {cbase nil?} :Kernel)} %1 ...)
+        PATTERN
+
+        # @!method string_constructor?(node)
+        def_node_matcher :string_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :String) :new ...)
+            #type_constructor?(:String)
+          }
+        PATTERN
+
+        # @!method integer_constructor?(node)
+        def_node_matcher :integer_constructor?, <<~PATTERN
+          #type_constructor?(:Integer)
+        PATTERN
+
+        # @!method float_constructor?(node)
+        def_node_matcher :float_constructor?, <<~PATTERN
+          #type_constructor?(:Float)
+        PATTERN
+
+        # @!method bigdecimal_constructor?(node)
+        def_node_matcher :bigdecimal_constructor?, <<~PATTERN
+          #type_constructor?(:BigDecimal)
+        PATTERN
+
+        # @!method rational_constructor?(node)
+        def_node_matcher :rational_constructor?, <<~PATTERN
+          #type_constructor?(:Rational)
+        PATTERN
+
+        # @!method complex_constructor?(node)
+        def_node_matcher :complex_constructor?, <<~PATTERN
+          #type_constructor?(:Complex)
+        PATTERN
+
+        # @!method array_constructor?(node)
+        def_node_matcher :array_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Array) {:new :[]} ...)
+            #type_constructor?(:Array)
+          }
+        PATTERN
+
+        # @!method hash_constructor?(node)
+        def_node_matcher :hash_constructor?, <<~PATTERN
+          {
+            (block (send (const {cbase nil?} :Hash) :new) ...)
+            (send (const {cbase nil?} :Hash) {:new :[]} ...)
+            (send {nil? (const {cbase nil?} :Kernel)} :Hash ...)
+          }
+        PATTERN
+
+        # @!method set_constructor?(node)
+        def_node_matcher :set_constructor?, <<~PATTERN
+          {
+            (send (const {cbase nil?} :Set) {:new :[]} ...)
+          }
+        PATTERN
+
+        # @!method exception_false_keyword_argument?(node)
+        def_node_matcher :exception_false_keyword_argument?, <<~PATTERN
+          (hash (pair (sym :exception) false))
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def on_send(node)
+          return if node.arguments.any? || hash_or_set_with_block?(node)
+
+          receiver = find_receiver(node)
+          return unless literal_receiver?(node, receiver) ||
+                        constructor?(node, receiver) ||
+                        chained_conversion?(node, receiver) ||
+                        chained_to_typed_method?(node, receiver)
+
+          message = format(MSG, method: node.method_name)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            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
+
+        def hash_or_set_with_block?(node)
+          return false if !node.method?(:to_h) && !node.method?(:to_set)
+
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
+
+        def find_receiver(node)
+          receiver = node.receiver
+          return unless receiver
+
+          while receiver.begin_type?
+            break unless receiver.children.one?
+
+            receiver = receiver.children.first
+          end
+
+          receiver
+        end
+
+        def literal_receiver?(node, receiver)
+          return false unless receiver
+
+          receiver.type?(*LITERAL_NODE_TYPES[node.method_name])
+        end
+
+        def constructor?(node, receiver)
+          matcher = CONSTRUCTOR_MAPPING[node.method_name]
+          return false unless matcher
+
+          public_send(matcher, receiver) && !constructor_suppresses_exceptions?(receiver)
+        end
+
+        def constructor_suppresses_exceptions?(receiver)
+          # If the constructor suppresses exceptions with `exception: false`, it is possible
+          # it could return `nil`, and therefore a chained conversion is not redundant.
+          receiver.arguments.any? { |arg| exception_false_keyword_argument?(arg) }
+        end
+
+        def chained_conversion?(node, receiver)
+          return false unless receiver&.call_type?
+
+          receiver.method?(node.method_name)
+        end
+
+        def chained_to_typed_method?(node, receiver)
+          return false unless receiver&.call_type?
+
+          TYPED_METHODS.fetch(node.method_name, []).include?(receiver.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,7 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -61,9 +62,11 @@ module RuboCop
           {
             (block
               $(call _ {:each_with_index :with_index} ...)
-              (args (arg _)) ...)
+              {(args (arg _)) (args)} ...)
             (numblock
               $(call _ {:each_with_index :with_index} ...) 1 ...)
+            (itblock
+              $(call _ {:each_with_index :with_index} ...) _ ...)
           }
         PATTERN
 

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # Checks for redundant `with_object`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because the return value changes:
+      #   `each_with_object` returns the memo object, while the corrected `each` returns
+      #   the receiver. This matters when the result of the expression is used.
+      #
       # @example
       #   # bad
       #   ary.each_with_object([]) do |v|
@@ -49,6 +54,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -59,6 +65,8 @@ module RuboCop
               $(call _ {:each_with_object :with_object} _) (args (arg _)) ...)
             (numblock
               $(call _ {:each_with_object :with_object} _) 1 ...)
+            (itblock
+              $(call _ {:each_with_object :with_object} _) _ ...)
           }
         PATTERN
 

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

@@ -32,9 +32,12 @@ module RuboCop
       #   end
       #
       class RefinementImportMethods < Base
+        extend AutoCorrector
         extend TargetRubyVersion
 
         MSG = 'Use `import_methods` instead of `%<current>s` because it is deprecated in Ruby 3.1.'
+        MSG_REMOVED = 'Use `import_methods` instead of `%<current>s` ' \
+                      'because it was removed in Ruby 3.2.'
         RESTRICT_ON_SEND = %i[include prepend].freeze
 
         minimum_target_ruby_version 3.1
@@ -44,7 +47,11 @@ module RuboCop
           return unless (parent = node.parent)
           return unless parent.block_type? && parent.method?(:refine)
 
-          add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
+          template = target_ruby_version >= 3.2 ? MSG_REMOVED : MSG
+          message = format(template, current: node.method_name)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, 'import_methods')
+          end
         end
       end
     end

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

@@ -26,7 +26,15 @@ module RuboCop
           return if node.ancestors.none?(&:conditional?)
           return if part_of_ignored_node?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+          add_offense(node) do |corrector|
+            # `!` binds tighter than `=~`, so `!/foo/ =~ $_` would parse as
+            # `(!/foo/) =~ $_`. Wrap the match in parentheses to preserve the meaning.
+            if node.parent&.send_type? && node.parent.method?(:!)
+              corrector.replace(node.parent, "!(#{node.source} =~ $_)")
+            else
+              corrector.replace(node, "#{node.source} =~ $_")
+            end
+          end
 
           ignore_node(node)
         end

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for expressions where there is a call to a predicate
-      # method with at least one argument, where no parentheses are used around
-      # the parameter list, and a boolean operator, && or ||, is used in the
-      # last argument.
+      # Checks for method calls with at least one argument where no parentheses
+      # are used around the parameter list, and the call could be misread as an
+      # operand of a boolean operator (`&&` or `||`). Two forms are flagged:
+      #
+      # * a predicate method whose last argument is a `&&`/`||` expression, and
+      # * any method whose first argument is a ternary expression with a
+      #   `&&`/`||` condition.
       #
       # The idea behind warning for these constructs is that the user might
       # be under the impression that the return value from the method call is
@@ -23,6 +26,12 @@ module RuboCop
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end
+      #
+      #   # bad
+      #   foo a && b ? c : d
+      #
+      #   # good
+      #   foo(a && b ? c : d)
       class RequireParentheses < Base
         include RangeHelp
 

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

@@ -38,12 +38,13 @@ module RuboCop
       #   42)
       #
       class RequireRangeParentheses < Base
-        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+        MSG = 'Wrap the range literal `%<range>s` in parentheses ' \
+              'to avoid confusion with an endless range.'
 
         def on_irange(node)
           return if node.parent&.begin_type?
           return unless node.begin && node.end
-          return if same_line?(node.begin, node.end)
+          return if same_line?(node.loc.operator, node.end)
 
           message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")