rubocop 1.69.2 → 1.73.1

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

@@ -67,7 +67,6 @@ module RuboCop
 
         MSG = 'Avoid `%<keyword>s` branches without a body.'
 
-        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
           return if cop_config['AllowComments'] && contains_comments?(node)
@@ -75,15 +74,21 @@ module RuboCop
           range = offense_range(node)
 
           add_offense(range, message: format(MSG, keyword: node.keyword)) do |corrector|
-            next if node.parent&.call_type?
-
-            autocorrect(corrector, node)
+            autocorrect(corrector, node) if do_autocorrect?(node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def do_autocorrect?(node)
+          # if condition; end.do_something
+          return false if (parent = node.parent)&.call_type?
+          # x = if condition; end
+          return false if (parent&.assignment? || parent&.operator_keyword?) && node.children.one?
+
+          true
+        end
+
         def offense_range(node)
           if node.loc.else
             node.source_range.begin.join(node.loc.else.begin)

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

@@ -14,8 +14,6 @@ module RuboCop
       #     bar
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   foo = (some_expression)

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
 
@@ -78,21 +81,16 @@ module RuboCop
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?
             float?(node.receiver) || float?(node.first_argument)
           elsif FLOAT_RETURNING_METHODS.include?(node.method_name)
             true
           elsif node.receiver&.float_type?
-            if FLOAT_INSTANCE_METHODS.include?(node.method_name)
-              true
-            else
+            FLOAT_INSTANCE_METHODS.include?(node.method_name) ||
               check_numeric_returning_method(node)
-            end
           end
         end
-        # rubocop:enable Metrics/PerceivedComplexity
 
         def check_numeric_returning_method(node)
           return false unless node.receiver

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

@@ -7,7 +7,7 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
-      # In addition it checks whether different formats are used in the same
+      # In addition, it checks whether different formats are used in the same
       # format string. Do not mix numbered, unnumbered, and named formats in
       # the same format string.
       #
@@ -73,7 +73,7 @@ module RuboCop
 
           first_arg = node.first_argument
           return false if num_of_expected_fields.zero? &&
-                          (first_arg.dstr_type? || first_arg.array_type?)
+                          first_arg.type?(:dstr, :array)
 
           matched_arguments_count?(num_of_expected_fields, num_of_format_args)
         end

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

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def string_literal?(node)
-          node.str_type? || node.dstr_type?
+          node.type?(:str, :dstr)
         end
 
         def string_literals?(node1, node2)

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

@@ -18,12 +18,15 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   if some_var && true
+      #   # We're only interested in the left hand side being a truthy literal,
+      #   # because it affects the evaluation of the &&, whereas the right hand
+      #   # side will be conditionally executed/called and can be a literal.
+      #   if true && some_var
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var && some_condition
+      #   if some_var
       #     do_something
       #   end
       #
@@ -34,27 +37,90 @@ module RuboCop
       #   end
       class LiteralAsCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Literal `%<literal>s` appeared as a condition.'
         RESTRICT_ON_SEND = [:!].freeze
 
+        def on_and(node)
+          return unless node.lhs.truthy_literal?
+
+          add_offense(node.lhs) do |corrector|
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
         def on_if(node)
-          check_for_literal(node)
+          cond = condition(node)
+
+          if node.unless?
+            correct_if_node(node, cond, true) if cond.falsey_literal?
+            correct_if_node(node, cond, false) if cond.truthy_literal?
+          else
+            correct_if_node(node, cond, true) if cond.truthy_literal?
+            correct_if_node(node, cond, false) if cond.falsey_literal?
+          end
         end
 
         def on_while(node)
-          return if condition(node).true_type?
+          return if node.condition.source == 'true'
 
-          check_for_literal(node)
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'true')
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_while_post(node)
+          return if node.condition.source == 'true'
+
+          if node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'true'))
+            end
+          elsif node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_while_post on_while
+        # rubocop:enable Metrics/AbcSize
 
         def on_until(node)
-          return if condition(node).false_type?
+          return if node.condition.source == 'false'
 
-          check_for_literal(node)
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'false')
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def on_until_post(node)
+          return if node.condition.source == 'false'
+
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.source.sub(node.condition.source, 'false'))
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_until_post on_until
+        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
           if case_node.condition
@@ -130,6 +196,8 @@ module RuboCop
 
         def handle_node(node)
           if node.literal?
+            return if node.parent.and_type?
+
             add_offense(node)
           elsif %i[send and or begin].include?(node.type)
             check_node(node)
@@ -159,6 +227,28 @@ module RuboCop
             when_node.conditions.last.source_range.end_pos
           )
         end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def correct_if_node(node, cond, result)
+          if result
+            add_offense(cond) do |corrector|
+              corrector.replace(node, node.if_branch.source)
+            end
+          elsif node.elsif_conditional?
+            add_offense(cond) do |corrector|
+              corrector.replace(node, "#{node.else_branch.source.sub('elsif', 'if')}\nend")
+            end
+          elsif node.else? || node.ternary?
+            add_offense(cond) do |corrector|
+              corrector.replace(node, node.else_branch.source)
+            end
+          else
+            add_offense(cond) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
       end
     end
   end

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)
@@ -181,7 +199,7 @@ module RuboCop
 
         def in_array_percent_literal?(node)
           parent = node.parent
-          return false unless parent.dstr_type? || parent.dsym_type?
+          return false unless parent.type?(:dstr, :dsym)
 
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?

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

@@ -97,7 +97,7 @@ module RuboCop
 
         # @!method class_new_block(node)
         def_node_matcher :class_new_block, <<~RUBY
-          ({block numblock}
+          (any_block
             (send
               (const {nil? cbase} :Class) :new $_) ...)
         RUBY
@@ -135,7 +135,7 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          if (block_node = node.each_ancestor(:block, :numblock).first)
+          if (block_node = node.each_ancestor(:any_block).first)
             return false unless (super_class = class_new_block(block_node))
 
             !allowed_class?(super_class)

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
@@ -79,7 +79,7 @@ module RuboCop
         end
 
         def range_pairs(expr)
-          RuboCop::Cop::Utils::RegexpRanges.new(expr).pairs
+          expr.expressions.filter_map { |e| [e.expressions[0], e.expressions[1]] if e.type == :set }
         end
 
         def unsafe_range?(range_start, range_end)
@@ -94,7 +94,7 @@ module RuboCop
 
         def skip_range?(range_start, range_end)
           [range_start, range_end].any? do |bound|
-            bound.type != :literal
+            bound&.type != :literal
           end
         end
 

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,13 +96,13 @@ 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
 
           within_scoping_def =
-            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
+            node.each_ancestor(:any_block, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -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
 
@@ -125,12 +129,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          (any_block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          (any_block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block, :numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end

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

@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.type?(:def, :defs) || node.lambda?
         end
 
         def return_value?(return_node)