rubocop 1.69.2 → 1.71.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate elements in Regexp character classes.
+      # Checks for duplicate elements in `Regexp` character classes.
       #
       # @example
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for duplicate literal, constant, or variable elements in Set.
+      # Checks for duplicate literal, constant, or variable elements in `Set` and `SortedSet`.
       #
       # @example
       #
@@ -25,17 +25,28 @@ module RuboCop
       #   # good
       #   [:foo, :bar].to_set
       #
+      #   # bad
+      #   SortedSet[:foo, :bar, :foo]
+      #
+      #   # good
+      #   SortedSet[:foo, :bar]
+      #
+      #   # bad
+      #   SortedSet.new([:foo, :bar, :foo])
+      #
+      #   # good
+      #   SortedSet.new([:foo, :bar])
       class DuplicateSetElement < Base
         extend AutoCorrector
 
-        MSG = 'Remove the duplicate element in Set.'
+        MSG = 'Remove the duplicate element in %<class_name>s.'
         RESTRICT_ON_SEND = %i[\[\] new to_set].freeze
 
         # @!method set_init_elements(node)
         def_node_matcher :set_init_elements, <<~PATTERN
           {
-            (send (const {nil? cbase} :Set) :[] $...)
-            (send (const {nil? cbase} :Set) :new (array $...))
+            (send (const {nil? cbase} {:Set :SortedSet}) :[] $...)
+            (send (const {nil? cbase} {:Set :SortedSet}) :new (array $...))
             (call (array $...) :to_set)
           }
         PATTERN
@@ -51,7 +62,7 @@ module RuboCop
             next if !set_element.literal? && !set_element.const_type? && !set_element.variable?
 
             if seen_elements.include?(set_element)
-              register_offense(set_element, set_elements[index - 1])
+              register_offense(set_element, set_elements[index - 1], node)
             else
               seen_elements << set_element
             end
@@ -61,8 +72,10 @@ module RuboCop
 
         private
 
-        def register_offense(current_element, prev_element)
-          add_offense(current_element) do |corrector|
+        def register_offense(current_element, prev_element, node)
+          class_name = node.receiver.const_type? ? node.receiver.const_name : 'Set'
+
+          add_offense(current_element, message: format(MSG, class_name: class_name)) do |corrector|
             range = prev_element.source_range.end.join(current_element.source_range.end)
 
             corrector.remove(range)

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

@@ -36,7 +36,8 @@ module RuboCop
       #   # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/
       #
       class FloatComparison < Base
-        MSG = 'Avoid (in)equality comparisons of floats as they are unreliable.'
+        MSG_EQUALITY = 'Avoid equality comparisons of floats as they are unreliable.'
+        MSG_INEQUALITY = 'Avoid inequality comparisons of floats as they are unreliable.'
 
         EQUALITY_METHODS = %i[== != eql? equal?].freeze
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
@@ -52,8 +53,10 @@ module RuboCop
 
           return if literal_safe?(lhs) || literal_safe?(rhs)
 
-          add_offense(node) if float?(lhs) || float?(rhs)
+          message = node.method?(:!=) ? MSG_INEQUALITY : MSG_EQUALITY
+          add_offense(node, message: message) if float?(lhs) || float?(rhs)
         end
+        alias on_csend on_send
 
         private
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Identifies Float literals which are, like, really really really
+      # Identifies `Float` literals which are, like, really really really
       # really really really really really big. Too big. No-one needs Floats
       # that big. If you need a float that big, something is wrong with you.
       #

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

@@ -5,6 +5,9 @@ module RuboCop
     module Lint
       # Checks for interpolated literals.
       #
+      # NOTE: Array literals interpolated in regexps are not handled by this cop, but
+      # by `Lint/ArrayLiteralInRegexp` instead.
+      #
       # @example
       #
       #   # bad
@@ -21,6 +24,7 @@ module RuboCop
         MSG = 'Literal interpolation detected.'
         COMPOSITE = %i[array hash pair irange erange].freeze
 
+        # rubocop:disable Metrics/AbcSize
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
           return unless offending?(final_node)
@@ -35,11 +39,18 @@ module RuboCop
           return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
 
           add_offense(final_node) do |corrector|
-            return if final_node.dstr_type? # nested, fixed in next iteration
+            next if final_node.dstr_type? # nested, fixed in next iteration
+
+            replacement = if final_node.str_type? && !final_node.value.valid_encoding?
+                            final_node.source.delete_prefix('"').delete_suffix('"')
+                          else
+                            expanded_value
+                          end
 
-            corrector.replace(final_node.parent, expanded_value)
+            corrector.replace(final_node.parent, replacement)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -47,8 +58,10 @@ module RuboCop
           node &&
             !special_keyword?(node) &&
             prints_as_self?(node) &&
-            # Special case for Layout/TrailingWhitespace
-            !(space_literal?(node) && ends_heredoc_line?(node))
+            # Special case for `Layout/TrailingWhitespace`
+            !(space_literal?(node) && ends_heredoc_line?(node)) &&
+            # Handled by `Lint/ArrayLiteralInRegexp`
+            !array_in_regexp?(node)
         end
 
         def special_keyword?(node)
@@ -56,6 +69,11 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
+        def array_in_regexp?(node)
+          grandparent = node.parent.parent
+          node.array_type? && grandparent.regexp_type?
+        end
+
         # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
@@ -168,7 +186,7 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.blank?
+          node.str_type? && node.value.valid_encoding? && node.value.blank?
         end
 
         def ends_heredoc_line?(node)

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

@@ -8,7 +8,7 @@ module RuboCop
       # Offenses are registered for regexp character classes like `/[A-z]/`
       # as well as range objects like `('A'..'z')`.
       #
-      # NOTE: Range objects cannot be autocorrected.
+      # NOTE: `Range` objects cannot be autocorrected.
       #
       # @safety
       #   The cop autocorrects regexp character classes

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

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

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

@@ -96,7 +96,7 @@ module RuboCop
 
         def on_def(node)
           subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          return if node.defs_type? && subject.variable?
+          return if node.defs_type? && allowed_subject_type?(subject)
 
           def_ancestor = node.each_ancestor(:def, :defs).first
           return unless def_ancestor
@@ -117,6 +117,10 @@ module RuboCop
             child.class_constructor? || allowed_method_name?(child)
         end
 
+        def allowed_subject_type?(subject)
+          subject.variable? || subject.const_type? || subject.call_type?
+        end
+
         def allowed_method_name?(node)
           name = node.method_name
 

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<~PATTERN
-          $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
         def_node_matcher :receiver_and_method_name, <<~PATTERN
-          (send (const nil? $_) $_ ...)
+          (send (const {cbase nil?} $_) $_ ...)
         PATTERN
 
         # @!method force?(node)
@@ -78,7 +78,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.receiver
+          return unless node.receiver&.const_type?
           return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
@@ -116,6 +116,7 @@ module RuboCop
 
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
+
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 

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

@@ -4,30 +4,27 @@ module RuboCop
   module Cop
     module Lint
       # Certain numeric operations have a constant result, usually 0 or 1.
-      # Subtracting a number from itself or multiplying it by 0 will always return 0.
-      # Additionally, a variable modulo 0 or itself will always return 0.
+      # Multiplying a number by 0 will always return 0.
       # Dividing a number by itself or raising it to the power of 0 will always return 1.
       # As such, they can be replaced with that result.
       # These are probably leftover from debugging, or are mistakes.
       # Other numeric operations that are similarly leftover from debugging or mistakes
       # are handled by Lint/UselessNumericOperation.
       #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
+      # a numeric operation.
+      #
       # @example
       #
       #   # bad
-      #   x - x
       #   x * 0
-      #   x % 1
-      #   x % x
       #
       #   # good
       #   0
       #
       #   # bad
-      #   x -= x
       #   x *= 0
-      #   x %= 1
-      #   x %= x
       #
       #   # good
       #   x = 0
@@ -49,57 +46,47 @@ module RuboCop
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
         MSG = 'Numeric operation with a constant result detected.'
-        RESTRICT_ON_SEND = %i[- * / % **].freeze
+        RESTRICT_ON_SEND = %i[* / **].freeze
 
         # @!method operation_with_constant_result?(node)
         def_node_matcher :operation_with_constant_result?,
-                         '(send (send nil? $_) $_ ({int | send nil?} $_))'
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
 
         # @!method abbreviated_assignment_with_constant_result?(node)
         def_node_matcher :abbreviated_assignment_with_constant_result?,
-                         '(op-asgn (lvasgn $_) $_ ({int | lvar} $_))'
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
-          return unless operation_with_constant_result?(node)
-
-          variable, operation, number = operation_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
             corrector.replace(node, result.to_s)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless abbreviated_assignment_with_constant_result?(node)
-
-          variable, operation, number = abbreviated_assignment_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{result}")
+            corrector.replace(node, "#{lhs} = #{result}")
           end
         end
 
         private
 
-        # rubocop :disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def constant_result?(variable, operation, number)
-          if number.to_s == '0'
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
             return 0 if operation == :*
             return 1 if operation == :**
-          elsif number.to_s == '1'
-            return 0 if operation == :%
-          elsif number == variable
-            return 0 if %i[- %].include?(operation)
+          elsif rhs == lhs
             return 1 if operation == :/
           end
           # If we weren't able to find any matches, return false so we can bail out.
           false
         end
-        # rubocop :enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Looks for references of Regexp captures that are out of range
+      # Looks for references of `Regexp` captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -61,6 +61,7 @@ module RuboCop
             check_regexp(node.receiver)
           end
         end
+        alias after_csend after_send
 
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result:

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(:send, :csend) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -97,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/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/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

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

@@ -55,12 +55,9 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            Regexp::Parser.parse(text.value)&.each_expression do |expr|
+            parse_regexp(text.value)&.each_expression do |expr|
               detect_offenses(text, expr)
             end
-          rescue Regexp::Parser::Error
-            # Upon encountering an invalid regular expression,
-            # we aim to proceed and identify any remaining potential offenses.
           end
         end
 

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

@@ -17,7 +17,7 @@ module RuboCop
       # rescue, ensure, etc.
       #
       # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
-      # operator assignment can cause NameError if this assignment has been used to declare
+      # operator assignment can cause `NameError` if this assignment has been used to declare
       # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
       # "undefined local variable or method `a' for main:Object (NameError)".
       #

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

@@ -35,7 +35,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(send (send nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
 
         # @!method useless_abbreviated_assignment?(node)
         def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
@@ -50,6 +50,7 @@ module RuboCop
             corrector.replace(node, variable)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
           return unless useless_abbreviated_assignment?(node)

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

@@ -113,7 +113,8 @@ module RuboCop
         end
 
         def check_expression(expr)
-          expr = expr.body if expr.if_type? && expr.modifier_form?
+          expr = expr.body if expr.if_type?
+          return unless expr
 
           check_literal(expr)
           check_var(expr)
@@ -229,7 +230,7 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
-          return if node.parent.if_type? && node.parent.modifier_form?
+          return if node.parent.if_type?
 
           corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
         end

data/lib/rubocop/cop/metrics/collection_literal_length.rb

@@ -52,12 +52,19 @@ module RuboCop
               'Prefer reading the data from an external source.'
         RESTRICT_ON_SEND = [:[]].freeze
 
+        # @!method set_const?(node)
+        def_node_matcher :set_const?, <<~PATTERN
+          (const {cbase nil?} :Set)
+        PATTERN
+
         def on_array(node)
           add_offense(node) if node.children.length >= collection_threshold
         end
         alias on_hash on_array
 
         def on_index(node)
+          return unless set_const?(node.receiver)
+
           add_offense(node) if node.arguments.length >= collection_threshold
         end
 

data/lib/rubocop/cop/metrics/cyclomatic_complexity.rb

@@ -36,7 +36,7 @@ module RuboCop
         include MethodComplexity
         include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Cyclomatic complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if while until for csend block block_pass
                            rescue when in_pattern and or or_asgn and_asgn].freeze
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -48,7 +48,7 @@ module RuboCop
         LABEL = 'Method'
 
         def on_def(node)
-          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if allowed?(node.method_name)
 
           check_code_length(node)
         end
@@ -57,6 +57,9 @@ module RuboCop
         def on_block(node)
           return unless node.method?(:define_method)
 
+          method_name = node.send_node.first_argument
+          return if method_name.basic_literal? && allowed?(method_name.value)
+
           check_code_length(node)
         end
         alias on_numblock on_block
@@ -66,6 +69,10 @@ module RuboCop
         def cop_label
           LABEL
         end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -27,7 +27,7 @@ module RuboCop
       #     end                           # ===
       #   end                             # 7 complexity points
       class PerceivedComplexity < CyclomaticComplexity
-        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
         COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze