rubocop 1.67.0 → 1.73.0

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

@@ -29,7 +29,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
-        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
@@ -42,7 +42,7 @@ module RuboCop
         def on_send(node)
           return if node.receiver
 
-          node.each_child_node(:send) do |child|
+          node.each_child_node(:call) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant uses of `to_s`, `to_sym`, `to_i`, `to_f`, `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()`, `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 of with `Float()`.
+      # * `to_r` when called on a rational literal or with `Rational()`.
+      # * `to_c` when called on a complex literal of 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 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`).
+      #
+      # @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 - 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
+      #   inspect.to_s
+      #
+      #   # good
+      #   inspect
+      #
+      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_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] }.freeze
+
+        CONVERSION_METHODS = Set[*LITERAL_NODE_TYPES.keys].freeze
+        RESTRICT_ON_SEND = CONVERSION_METHODS
+
+        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 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
+        def on_send(node)
+          return if 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.selector))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        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/refinement_import_methods.rb

@@ -6,7 +6,7 @@ module RuboCop
       # Checks if `include` or `prepend` is called in `refine` block.
       # These methods are deprecated and should be replaced with `Refinement#import_methods`.
       #
-      # It emulates deprecation warnings in Ruby 3.1.
+      # It emulates deprecation warnings in Ruby 3.1. Functionality has been removed in Ruby 3.2.
       #
       # @safety
       #   This cop's autocorrection is unsafe because `include M` will affect the included class

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

@@ -17,7 +17,6 @@ module RuboCop
       #     do_something
       #   end
       class RegexpAsCondition < Base
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Do not use regexp literal as a condition. ' \

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the `Exception` class.
       #
       # @example
       #

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

@@ -42,15 +42,11 @@ module RuboCop
         INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
 
         def on_resbody(node)
-          rescued, _, _body = *node
-          return if rescued.nil?
-
-          exceptions = *rescued
-          invalid_exceptions = invalid_exceptions(exceptions)
+          invalid_exceptions = invalid_exceptions(node.exceptions)
           return if invalid_exceptions.empty?
 
           add_offense(
-            node.loc.keyword.join(rescued.source_range),
+            node.loc.keyword.join(node.children.first.source_range),
             message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
@@ -58,7 +54,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          rescued, _, _body = *node
+          rescued = node.children.first
           range = node.loc.keyword.end.join(rescued.source_range.end)
 
           corrector.replace(range, correction(*rescued))

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

@@ -33,11 +33,13 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $({block numblock} (csend ...) ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
           }
         PATTERN
 
         def on_send(node)
+          return unless require_safe_navigation?(node)
+
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
@@ -52,6 +54,13 @@ module RuboCop
 
         private
 
+        def require_safe_navigation?(node)
+          parent = node.parent
+          return true unless parent&.and_type?
+
+          parent.rhs != node || parent.lhs.receiver != parent.rhs.receiver
+        end
+
         # @param [Parser::Source::Range] offense_range
         # @param [RuboCop::AST::SendNode] send_node
         # @return [String]
@@ -88,12 +97,19 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
+          return true if operator_inside_hash?(send_node)
           return false unless send_node.comparison_method?
           return false unless (node = send_node.parent)
 
           (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
             (node.respond_to?(:comparison_method?) && node.comparison_method?)
         end
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
       end
     end
   end

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

@@ -83,6 +83,8 @@ module RuboCop
         def find_consistent_parts(grouped_operands)
           csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
+          return if csend_in_and && csend_in_or && csend_in_and < csend_in_or
+
           if csend_in_and
             ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
           elsif send_in_or && csend_in_or
@@ -94,7 +96,9 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def already_appropriate_call?(operand, dot_op)
-          (operand.safe_navigation? && dot_op == '&.') || (operand.dot? && dot_op == '.')
+          return true if operand.safe_navigation? && dot_op == '&.'
+
+          (operand.dot? || operand.operator_method?) && dot_op == '.'
         end
 
         def register_offense(operand, dot_operator)

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

@@ -43,23 +43,21 @@ module RuboCop
         alias on_csend on_send
 
         def on_lvasgn(node)
-          lhs, rhs = *node
-          return unless rhs
+          return unless node.rhs
 
           rhs_type = ASSIGNMENT_TYPE_TO_RHS_TYPE[node.type]
 
-          add_offense(node) if rhs.type == rhs_type && rhs.source == lhs.to_s
+          add_offense(node) if node.rhs.type == rhs_type && node.rhs.source == node.lhs.to_s
         end
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
         def on_casgn(node)
-          lhs_scope, lhs_name, rhs = *node
-          return unless rhs&.const_type?
+          return unless node.rhs&.const_type?
 
-          rhs_scope, rhs_name = *rhs
-          add_offense(node) if lhs_scope == rhs_scope && lhs_name == rhs_name
+          add_offense(node) if node.namespace == node.rhs.namespace &&
+                               node.short_name == node.rhs.short_name
         end
 
         def on_masgn(node)
@@ -67,15 +65,15 @@ module RuboCop
         end
 
         def on_or_asgn(node)
-          lhs, rhs = *node
-          add_offense(node) if rhs_matches_lhs?(rhs, lhs)
+          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
         end
         alias on_and_asgn on_or_asgn
 
         private
 
         def multiple_self_assignment?(node)
-          lhs, rhs = *node
+          lhs = node.lhs
+          rhs = node.rhs
           return false unless rhs.array_type?
           return false unless lhs.children.size == rhs.children.size
 

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

@@ -67,7 +67,7 @@ module RuboCop
         def on_rescue(node)
           return if rescue_modifier?(node)
 
-          _body, *rescues, _else = *node
+          rescues = node.resbody_branches
           rescued_groups = rescued_groups_for(rescues)
 
           rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `Hash` creation with a mutable default value.
+      # Creating a `Hash` in such a way will share the default value
+      # across all keys, causing unexpected behavior when modifying it.
+      #
+      # For example, when the `Hash` was created with an `Array` as the argument,
+      # calling `hash[:foo] << 'bar'` will also change the value of all
+      # other keys that have not been explicitly assigned to.
+      #
+      # @example
+      #   # bad
+      #   Hash.new([])
+      #   Hash.new({})
+      #   Hash.new(Array.new)
+      #   Hash.new(Hash.new)
+      #
+      #   # okay -- In rare cases that intentionally have this behavior,
+      #   #   without disabling the cop, you can set the default explicitly.
+      #   h = Hash.new
+      #   h.default = []
+      #   h[:a] << 1
+      #   h[:b] << 2
+      #   h # => {:a => [1, 2], :b => [1, 2]}
+      #
+      #   # okay -- beware this will discard mutations and only remember assignments
+      #   Hash.new { Array.new }
+      #   Hash.new { Hash.new }
+      #   Hash.new { {} }
+      #   Hash.new { [] }
+      #
+      #   # good - frozen solution will raise an error when mutation attempted
+      #   Hash.new([].freeze)
+      #   Hash.new({}.freeze)
+      #
+      #   # good - using a proc will create a new object for each key
+      #   h = Hash.new
+      #   h.default_proc = ->(h, k) { [] }
+      #   h.default_proc = ->(h, k) { {} }
+      #
+      #   # good - using a block will create a new object for each key
+      #   Hash.new { |h, k| h[k] = [] }
+      #   Hash.new { |h, k| h[k] = {} }
+      class SharedMutableDefault < Base
+        MSG = 'Do not create a Hash with a mutable default value ' \
+              'as the default value can accidentally be changed.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_initialized_with_mutable_shared_object?(node)
+        def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
+          (send (const {nil? cbase} :Hash) :new {array hash (send (const {nil? cbase} {:Array :Hash}) :new)})
+        PATTERN
+
+        def on_send(node)
+          return unless hash_initialized_with_mutable_shared_object?(node)
+
+          add_offense(node)
+        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, :block, :numblock).first
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :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,111 @@
+# 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 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
+
+          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
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        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

@@ -78,7 +78,7 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if node.receiver.str_type? || node.receiver.sym_type?
+          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}\"")

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

@@ -6,9 +6,12 @@ module RuboCop
       # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-          processed_source.diagnostics.each do |diagnostic|
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
             add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super