rubocop 1.67.0 → 1.75.5

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

@@ -21,8 +21,6 @@ module RuboCop
       #   # File consisting only of comments
       #
       class EmptyFile < Base
-        include RangeHelp
-
         MSG = 'Empty file detected.'
 
         def on_new_investigation

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

@@ -43,7 +43,7 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.body&.each_node(:return) { |return_node| add_offense(return_node) }
+          node.branch&.each_node(:return) { |return_node| add_offense(return_node) }
         end
       end
     end

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

@@ -156,12 +156,6 @@ module RuboCop
 
           overridden_kwargs
         end
-
-        def arguments_range(node)
-          arguments = node.arguments
-
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        end
       end
     end
   end

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

@@ -29,11 +29,15 @@ module RuboCop
       #   tolerance = 0.0001
       #   (x - 0.1).abs < tolerance
       #
+      #   # good - comparing against nil
+      #   Float(x, exception: false) == nil
+      #
       #   # Or some other epsilon based type of comparison:
       #   # 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
@@ -42,11 +46,17 @@ module RuboCop
         RESTRICT_ON_SEND = EQUALITY_METHODS
 
         def on_send(node)
-          lhs, _method, rhs = *node
-          return if literal_zero?(lhs) || literal_zero?(rhs)
+          return unless node.arguments.one?
+
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          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
 
@@ -65,26 +75,22 @@ module RuboCop
           end
         end
 
-        def literal_zero?(node)
-          node&.numeric_type? && node.value.zero?
+        def literal_safe?(node)
+          return false unless node
+
+          (node.numeric_type? && node.value.zero?) || node.nil_type?
         end
 
-        # rubocop:disable Metrics/PerceivedComplexity
         def check_send(node)
           if node.arithmetic_operation?
-            lhs, _operation, rhs = *node
-            float?(lhs) || float?(rhs)
+            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.
       #
@@ -18,9 +18,7 @@ module RuboCop
         MSG = 'Float out of range.'
 
         def on_float(node)
-          value, = *node
-
-          return unless value.infinite? || (value.zero? && /[1-9]/.match?(node.source))
+          return unless node.value.infinite? || (node.value.zero? && /[1-9]/.match?(node.source))
 
           add_offense(node)
         end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for the deprecated use of keyword arguments as a default in `Hash.new`.
+      #
+      # This usage raises a warning in Ruby 3.3 and results in an error in Ruby 3.4.
+      # In Ruby 3.4, keyword arguments will instead be used to change the behavior of a hash.
+      # For example, the capacity option can be passed to create a hash with a certain size
+      # if you know it in advance, for better performance.
+      #
+      # NOTE: The following corner case may result in a false negative when upgrading from Ruby 3.3
+      # or earlier, but it is intentionally not detected to respect the expected usage in Ruby 3.4.
+      #
+      # [source,ruby]
+      # ----
+      # Hash.new(capacity: 42)
+      # ----
+      #
+      # @example
+      #
+      #   # bad
+      #   Hash.new(key: :value)
+      #
+      #   # good
+      #   Hash.new({key: :value})
+      #
+      class HashNewWithKeywordArgumentsAsDefault < Base
+        extend AutoCorrector
+
+        MSG = 'Use a hash literal instead of keyword arguments.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_new(node)
+        def_node_matcher :hash_new, <<~PATTERN
+          (send (const {nil? (cbase)} :Hash) :new $[hash !braces?])
+        PATTERN
+
+        def on_send(node)
+          return unless (first_argument = hash_new(node))
+
+          if first_argument.pairs.one?
+            key = first_argument.pairs.first.key
+            return if key.respond_to?(:value) && key.value == :capacity
+          end
+
+          add_offense(first_argument) do |corrector|
+            corrector.wrap(first_argument, '{', '}')
+          end
+        end
+      end
+    end
+  end
+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/interpolation_check.rb

@@ -24,14 +24,17 @@ module RuboCop
         MSG = 'Interpolation in single quoted string detected. ' \
               'Use double quoted strings if you need interpolation.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_str(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
           return unless node.loc.begin && node.loc.end
+          return unless valid_syntax?(node)
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -49,6 +52,12 @@ module RuboCop
         def heredoc?(node)
           node.loc.is_a?(Parser::Source::Map::Heredoc) || (node.parent && heredoc?(node.parent))
         end
+
+        def valid_syntax?(node)
+          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+
+          parse(double_quoted_string).valid_syntax?
+        end
       end
     end
   end

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

@@ -26,6 +26,9 @@ module RuboCop
       #
       class ItWithoutArgumentsInBlock < Base
         include NodePattern::Macros
+        extend TargetRubyVersion
+
+        maximum_target_ruby_version 3.3
 
         MSG = '`it` calls without arguments will refer to the first block param in Ruby 3.4; ' \
               'use `it()` or `self.it`.'

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,26 +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|
+            # Don't autocorrect `'foo' && return` because having `return` as
+            # the leftmost node can lead to a void value expression syntax error.
+            next if node.rhs.type?(:return, :break, :next)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
 
         def on_if(node)
-          check_for_literal(node)
+          cond = condition(node)
+
+          return unless cond.falsey_literal? || cond.truthy_literal?
+
+          correct_if_node(node, cond)
         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
-        alias on_while_post on_while
+
+        # 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
+        # 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
-        alias on_until_post on_until
+
+        # 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
+        # rubocop:enable Metrics/AbcSize
 
         def on_case(case_node)
           if case_node.condition
@@ -129,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)
@@ -158,6 +227,46 @@ module RuboCop
             when_node.conditions.last.source_range.end_pos
           )
         end
+
+        def condition_evaluation(node, cond)
+          if node.unless?
+            cond.falsey_literal?
+          else
+            cond.truthy_literal?
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def correct_if_node(node, cond)
+          result = condition_evaluation(node, cond)
+
+          if node.elsif? && result
+            add_offense(cond) do |corrector|
+              corrector.replace(node, "else\n  #{node.if_branch.source}")
+            end
+          elsif node.elsif? && !result
+            add_offense(cond) do |corrector|
+              corrector.replace(node, "else\n  #{node.else_branch.source}")
+            end
+          elsif node.if_branch && 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, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -40,7 +40,7 @@ module RuboCop
           traverse_node(node.condition) do |asgn_node|
             next unless asgn_node.loc.operator
 
-            rhs = asgn_node.to_a.last
+            rhs = asgn_node.rhs
             next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
 
             range = offense_range(asgn_node, rhs)

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

@@ -52,7 +52,7 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, (0..0))
+            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
             add_offense(range, message: message(cop, comment))

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
@@ -36,12 +36,9 @@ module RuboCop
 
         def on_irange(node)
           return unless node.children.compact.all?(&:str_type?)
+          return if node.begin.nil? || node.end.nil?
 
-          range_start, range_end = node.children
-
-          return if range_start.nil? || range_end.nil?
-
-          add_offense(node) if unsafe_range?(range_start.value, range_end.value)
+          add_offense(node) if unsafe_range?(node.begin.value, node.end.value)
         end
         alias on_erange on_irange
 
@@ -82,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)
@@ -97,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

@@ -95,14 +95,14 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node
-          return if node.defs_type? && subject.variable?
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return if node.defs_type? && allowed_subject_type?(subject)
 
-          def_ancestor = node.each_ancestor(:def, :defs).first
+          def_ancestor = node.each_ancestor(:any_def).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/no_return_in_begin_end_blocks.rb

@@ -45,8 +45,8 @@ module RuboCop
             end
           end
         end
-        alias on_or_asgn    on_lvasgn
-        alias on_op_asgn    on_lvasgn
+        alias on_or_asgn on_lvasgn
+        alias on_op_asgn on_lvasgn
       end
     end
   end