rubocop 1.87.0 → 1.88.0

data/lib/rubocop/cop/style/and_or.rb

@@ -71,7 +71,7 @@ module RuboCop
             node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
-              elsif expr.return_type? || expr.assignment?
+              elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
                 correct_other(expr, corrector)
               end
             end

data/lib/rubocop/cop/style/array_first_last.rb

@@ -40,8 +40,9 @@ module RuboCop
 
           node = innermost_braces_node(node)
           return if node.parent && brace_method?(node.parent)
+          return if compound_assignment_target?(node)
 
-          preferred = (value.zero? ? 'first' : 'last')
+          preferred = preferred_name(value)
           offense_range = find_offense_range(node)
 
           add_offense(offense_range, message: format(MSG, preferred: preferred)) do |corrector|
@@ -53,6 +54,10 @@ module RuboCop
 
         private
 
+        def preferred_name(value)
+          value.zero? ? 'first' : 'last'
+        end
+
         def preferred_value(node, value)
           value = ".#{value}" unless node.loc.dot
           value
@@ -74,6 +79,12 @@ module RuboCop
         def brace_method?(node)
           node.send_type? && (node.method?(:[]) || node.method?(:[]=))
         end
+
+        # `arr[0] += 1` etc. would autocorrect to `arr.first += 1`, which calls the
+        # nonexistent `first=`/`last=` setter and raises `NoMethodError`.
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
+        end
       end
     end
   end

data/lib/rubocop/cop/style/array_intersect.rb

@@ -145,6 +145,10 @@ module RuboCop
 
           dot = dot_node.loc.dot.source
           bang = straight?(method_name) ? '' : '!'
+          # `a&.intersection(b)&.none?` returns `nil` when `a` is `nil`, but the negated
+          # rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return if bang == '!' && dot == '&.'
+
           replacement = "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})"
 
           register_offense(node, replacement)

data/lib/rubocop/cop/style/array_intersect_with_single_element.rb

@@ -29,6 +29,9 @@ module RuboCop
         def on_send(node)
           array, element = single_element(node)
           return unless array
+          # `[*foo]` is not a single element: the splat can expand to any number of
+          # elements, so `intersect?([*foo])` is not equivalent to `include?(*foo)`.
+          return if element.splat_type?
 
           add_offense(
             node.source_range.with(begin_pos: node.loc.selector.begin_pos)

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -389,9 +389,23 @@ module RuboCop
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
-          return false unless (resbody = node.each_descendant(:resbody).first)
 
-          resbody.children.first&.array_type?
+          body = node.body
+          return false unless body
+          # `ensure` and a block-level `rescue` are illegal inside `{ }`; only a
+          # bare modifier rescue (`expr rescue expr`) can be written with braces.
+          return true if body.ensure_type?
+          return false unless body.rescue_type?
+
+          !modifier_rescue?(body)
+        end
+
+        def modifier_rescue?(rescue_node)
+          return false if rescue_node.body.nil? || rescue_node.else_branch
+          return false unless rescue_node.resbody_branches.one?
+
+          resbody = rescue_node.resbody_branches.first
+          resbody.exceptions.empty? && resbody.exception_variable.nil?
         end
 
         def braces_required_method?(method_name)

data/lib/rubocop/cop/style/case_equality.rb

@@ -96,13 +96,25 @@ module RuboCop
         end
 
         def const_replacement(lhs, rhs)
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
         end
 
         def send_replacement(lhs, rhs)
           return unless self_class?(lhs)
 
-          "#{rhs.source}.is_a?(#{lhs.source})"
+          "#{parenthesize_if_needed(rhs)}.is_a?(#{lhs.source})"
+        end
+
+        # `Array === a + b` must become `(a + b).is_a?(Array)`, not
+        # `a + b.is_a?(Array)` (which parses as `a + (b.is_a?(Array))`).
+        def parenthesize_if_needed(node)
+          requires_parentheses?(node) ? "(#{node.source})" : node.source
+        end
+
+        def requires_parentheses?(node)
+          return true if node.type?(:and, :or, :if, :range) || node.assignment?
+
+          node.send_type? && (node.operator_method? || node.unary_operation?)
         end
       end
     end

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -90,25 +90,33 @@ module RuboCop
         private
 
         def class_name(class_node, node)
-          if class_name_method?(node.children.first.method_name)
-            if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
-              return receiver.source
-            end
+          unless class_name_method?(node.children.first.method_name)
+            # `var.class == 'Foo'` compares a `Class` to a `String` (always false) and
+            # has no valid `instance_of?` rewrite, so don't suggest one.
+            return if class_node.str_type?
 
-            if class_node.str_type?
-              value = trim_string_quotes(class_node)
-              value.prepend('::') if require_cbase?(class_node)
-              return value
-            elsif unable_to_determine_type?(class_node)
-              # When a variable or return value of a method is used, it returns nil
-              # because the type is not known and cannot be suggested.
-              return
-            end
+            return class_node.source
+          end
+
+          if (receiver = class_node.receiver) && class_name_method?(class_node.method_name)
+            return receiver.source
           end
 
+          return string_class_name(class_node) if class_node.str_type?
+          # When a variable or return value of a method is used, the type is not known
+          # and cannot be suggested.
+          return if unable_to_determine_type?(class_node)
+
           class_node.source
         end
 
+        def string_class_name(class_node)
+          value = trim_string_quotes(class_node)
+          # Avoid `::::Foo` when the name is already fully qualified.
+          value.prepend('::') if require_cbase?(class_node) && !value.start_with?('::')
+          value
+        end
+
         def class_name_method?(method_name)
           CLASS_NAME_METHODS.include?(method_name)
         end

data/lib/rubocop/cop/style/class_methods_definitions.rb

@@ -140,15 +140,21 @@ module RuboCop
 
         def extract_def_from_sclass(def_node, sclass_node)
           range = source_range_with_comment(def_node)
-          source = range.source.sub!(
-            "def #{def_node.method_name}",
-            "def self.#{def_node.method_name}"
-          )
-
+          source = prefix_def_with_self(range, def_node)
           source = source.gsub(/^ {#{indentation_diff(def_node, sclass_node)}}/, '')
           [range, source.chomp]
         end
 
+        # Splice in `self.` at the actual `def` keyword rather than substituting the
+        # first textual `def <name>`, which may appear inside a preceding comment.
+        def prefix_def_with_self(range, def_node)
+          keyword_offset = def_node.loc.keyword.begin_pos - range.begin_pos
+          name_end_offset = def_node.loc.name.end_pos - range.begin_pos
+          source = range.source.dup
+          source[keyword_offset...name_end_offset] = "def self.#{def_node.method_name}"
+          source
+        end
+
         def indentation_diff(node1, node2)
           node1.loc.column - node2.loc.column
         end

data/lib/rubocop/cop/style/colon_method_call.rb

@@ -24,10 +24,9 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
-        # @!method java_type_node?(node)
-        def_node_matcher :java_type_node?, <<~PATTERN
-          (send
-            (const nil? :Java) _)
+        # @!method java_root?(node)
+        def_node_matcher :java_root?, <<~PATTERN
+          (const nil? :Java)
         PATTERN
 
         def self.autocorrect_incompatible_with
@@ -37,11 +36,19 @@ module RuboCop
         def on_send(node)
           return unless node.receiver && node.double_colon?
           return if node.camel_case_method?
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
+          # ignore Java interop code like `Java::int` or `Java::com::method`
+          return if java_interop?(node)
 
           add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
+
+        private
+
+        def java_interop?(node)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver.respond_to?(:receiver) && receiver.receiver
+          java_root?(receiver)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -85,8 +85,13 @@ module RuboCop
         def on_for(node)
           return unless node.parent&.begin_type?
           return unless same_collection_looping_for?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
 
           add_offense(node) do |corrector|
+            # Combining loops with different iteration variables would leave the second
+            # body referencing an undefined variable, so only autocorrect when they match.
+            next unless node.variable == node.left_sibling.variable
+
             combine_with_left_sibling(corrector, node)
           end
         end

data/lib/rubocop/cop/style/comparable_clamp.rb

@@ -90,7 +90,7 @@ module RuboCop
             max = if_body.source
           end
 
-          prefer = "#{else_body_source}.clamp(#{min}, #{max})"
+          prefer = "#{parenthesize_if_needed(else_body)}.clamp(#{min}, #{max})"
 
           add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
             autocorrect(corrector, node, prefer)
@@ -119,6 +119,17 @@ module RuboCop
 
           (lhs.source == else_body && op == :<) || (rhs.source == else_body && op == :>)
         end
+
+        # `a + b` must become `(a + b).clamp(low, high)`, not `a + b.clamp(low, high)`
+        # (which parses as `a + (b.clamp(low, high))`).
+        def parenthesize_if_needed(node)
+          if node.type?(:and, :or, :if, :range) || node.assignment? ||
+             (node.send_type? && (node.operator_method? || node.unary_operation?))
+            "(#{node.source})"
+          else
+            node.source
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/concat_array_literals.rb

@@ -55,6 +55,10 @@ module RuboCop
               next unless prefer
 
               corrector.replace(offense, prefer)
+            elsif node.arguments.any? { |argument| argument.children.empty? }
+              # In-place bracket removal would leave dangling commas (e.g.
+              # `concat([], [b])` -> `push(, b)`), so rebuild the call instead.
+              corrector.replace(offense, preferred_method(node))
             else
               corrector.replace(node.loc.selector, 'push')
               node.arguments.each do |argument|
@@ -75,7 +79,7 @@ module RuboCop
 
         def preferred_method(node)
           new_arguments =
-            node.arguments.map do |arg|
+            node.arguments.flat_map do |arg|
               if arg.percent_literal?
                 arg.children.map { |child| child.value.inspect }
               else

data/lib/rubocop/cop/style/conditional_assignment.rb

@@ -283,7 +283,10 @@ module RuboCop
 
           _condition, *branches, else_branch = *assignment
 
-          return unless else_branch
+          # Use the node accessor rather than the raw destructured branch: for
+          # `x = unless cond; body; end` (no `else`) the parser puts `body` in the
+          # else slot, but `else_branch` correctly reports there is no `else` clause.
+          return unless assignment.else_branch
           return if allowed_single_line?([*branches, else_branch])
 
           add_offense(node, message: ASSIGN_TO_CONDITION_MSG) do |corrector|
@@ -657,6 +660,8 @@ module RuboCop
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
             parent_keyword = branch.parent.loc.keyword
+            return if same_line?(parent_keyword, condition)
+
             corrector.remove_preceding(parent_keyword, parent_keyword.column - column)
           end
         end

data/lib/rubocop/cop/style/constant_visibility.rb

@@ -89,7 +89,10 @@ module RuboCop
 
             arguments = arguments.first.children.first.to_a if arguments.first&.splat_type?
             constant_values = arguments.map do |argument|
-              argument.value.to_sym if argument.respond_to?(:value)
+              # `respond_to?(:value)` is too broad: `int`/`float` nodes respond to it
+              # but their value is a `Numeric`, which has no `to_sym` (e.g.
+              # `private_constant 42`). Only symbol/string arguments are real names.
+              argument.value.to_sym if argument.type?(:sym, :str)
             end
 
             constant_values.include?(node.name)

data/lib/rubocop/cop/style/date_time.rb

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method historic_date?(node)
         def_node_matcher :historic_date?, <<~PATTERN
-          (send _ _ _ (const (const {nil? (cbase)} :Date) _))
+          (call _ _ _ (const (const {nil? (cbase)} :Date) _))
         PATTERN
 
         # @!method to_datetime?(node)
         def_node_matcher :to_datetime?, <<~PATTERN
-          (call _ :to_datetime)
+          (call !nil? :to_datetime)
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/style/dig_chain.rb

@@ -79,6 +79,11 @@ module RuboCop
             corrector.replace(range, replacement)
 
             comments_in_range(node).reverse_each do |comment|
+              # Only relocate comments that the replacement destroys. A trailing
+              # comment after the chain survives in place, so moving it would
+              # duplicate it (and splitting the line drops the indentation).
+              next if comment.source_range.begin_pos >= range.end_pos
+
               corrector.insert_before(node, "#{comment.source}\n")
             end
           end

data/lib/rubocop/cop/style/fetch_env_var.rb

@@ -70,7 +70,7 @@ module RuboCop
 
         def allowed_var?(node)
           env_key_node = node.children.last
-          env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
+          env_key_node.str_type? && cop_config['AllowedVariables'].include?(env_key_node.value)
         end
 
         def used_as_flag?(node)

data/lib/rubocop/cop/style/file_write.rb

@@ -104,30 +104,33 @@ module RuboCop
 
         def replacement(mode, filename, content, write_node)
           replacement = "#{write_method(mode)}(#{filename.source}, #{content.source})"
-          heredoc = heredoc_in_write(write_node)
-          return replacement unless heredoc
+          heredocs = removed_heredocs(filename, content, write_node)
+          return replacement if heredocs.empty?
 
-          <<~REPLACEMENT.chomp
-            #{replacement}
-            #{heredoc_range(heredoc).source}
-          REPLACEMENT
+          [replacement, *heredocs.map { |heredoc| heredoc_range(heredoc).source }].join("\n")
         end
 
-        def heredoc_in_write(write_node)
-          return unless write_node.block_type? && (first_argument = write_node.body.first_argument)
-
-          find_heredoc(first_argument)
+        # Heredocs opened in the arguments keep working in the replacement, but their
+        # bodies are lost when they lie within the replaced range, so they need to be
+        # restored after the replacement.
+        def removed_heredocs(filename, content, write_node)
+          [filename, content].flat_map { |argument| find_heredocs(argument) }
+                             .select { |heredoc| removed?(heredoc, write_node) }
+                             .sort_by { |heredoc| heredoc.loc.heredoc_body.begin_pos }
         end
 
         def heredoc_range(heredoc)
           range_between(heredoc.loc.heredoc_body.begin_pos, heredoc.loc.heredoc_end.end_pos)
         end
 
-        def find_heredoc(node)
-          return node if node.respond_to?(:heredoc?) && node.heredoc?
-          return if node.send_type? && !(receiver = node.receiver)
+        def find_heredocs(node)
+          [node, *node.each_descendant(:any_str)].select do |child|
+            child.respond_to?(:heredoc?) && child.heredoc?
+          end
+        end
 
-          find_heredoc(receiver)
+        def removed?(heredoc, write_node)
+          heredoc.loc.heredoc_end.end_pos <= write_node.source_range.end_pos
         end
       end
     end

data/lib/rubocop/cop/style/hash_slice.rb

@@ -19,6 +19,22 @@ module RuboCop
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is a `Hash` or responds to the replacement method.
       #
+      #   Additionally, the replacement may change the order of the resulting
+      #   hash: `Hash#slice` returns entries in the order the keys are given,
+      #   whereas `select`, `filter`, and `reject` preserve the entry order of
+      #   the receiver.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   hash = {foo: 1, bar: 2, baz: 3}
+      #   keys = %i[baz foo]
+      #
+      #   hash.select { |k, _v| keys.include?(k) } # => {foo: 1, baz: 3}
+      #   hash.slice(*keys)                        # => {baz: 3, foo: 1}
+      #   ----
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -86,7 +86,7 @@ module RuboCop
         MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
-          [Style::SoleNestedConditional]
+          [Style::Next, Style::SoleNestedConditional]
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/rubocop/cop/style/mutable_constant.rb

@@ -6,6 +6,14 @@ module RuboCop
       # Checks whether some constant value isn't a
       # mutable literal (e.g. array or hash).
       #
+      # When the `Recursive` option is enabled, mutable literals nested inside
+      # arrays and hashes are also frozen, so an offense on the outermost
+      # unfrozen literal will autocorrect every nested mutable literal as well.
+      # When the outer literal already has `.freeze` appended, the cop descends
+      # into it and reports each outermost unfrozen literal underneath. The
+      # option is disabled by default to preserve existing behavior; opt in to
+      # get strict nested freezing.
+      #
       # Strict mode can be used to freeze all constants, rather than
       # just literals.
       # Strict mode is considered an experimental feature. It has not been
@@ -49,6 +57,17 @@ module RuboCop
       #   CONST = Something.new
       #
       #
+      # @example Recursive: false (default)
+      #   # good - only the outer container needs to be frozen
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      # @example Recursive: true
+      #   # bad - nested mutable literals must be frozen too
+      #   CONST = [{ a: [], b: 'foo' }].freeze
+      #
+      #   # good
+      #   CONST = [{ a: [].freeze, b: 'foo'.freeze }.freeze].freeze
+      #
       # @example EnforcedStyle: strict
       #   # bad
       #   CONST = Something.new
@@ -138,10 +157,30 @@ module RuboCop
         private
 
         def on_assignment(value)
-          if style == :strict
-            strict_check(value)
+          nodes = mutable_nodes(value) do |node|
+            if style == :strict
+              strict_check(node)
+            else
+              literal_check(node)
+            end
+          end
+
+          nodes.each do |node|
+            add_offense(node) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        def mutable_nodes(value, &block)
+          if recursive? && explicitly_frozen_literal?(value)
+            literal_children(value.receiver).flat_map { |c| mutable_nodes(c, &block) }
           else
-            check(value)
+            node_offending = yield(value)
+
+            if node_offending
+              [value]
+            else
+              []
+            end
           end
         end
 
@@ -151,18 +190,20 @@ module RuboCop
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
         end
 
-        def check(value)
-          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
-          return unless mutable_literal?(value) ||
-                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
-
+        def literal_check(value)
+          return unless mutable_or_unfrozen_range?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
 
-          add_offense(value) { |corrector| autocorrect(corrector, value) }
+          true
+        end
+
+        def mutable_or_unfrozen_range?(value)
+          mutable_literal?(value) ||
+            (target_ruby_version <= 2.7 && range_enclosed_in_parentheses?(value))
         end
 
         def autocorrect(corrector, node)
@@ -171,13 +212,66 @@ module RuboCop
           splat_value = splat_value(node)
           if splat_value
             correct_splat_expansion(corrector, expr, splat_value)
-          elsif node.array_type? && !node.bracketed?
+            corrector.insert_after(expr, '.freeze')
+            return
+          end
+
+          if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
 
           corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        # Recursively freezes every nested mutable literal inside an array or
+        # hash literal. Already-frozen subtrees are not re-frozen, but their
+        # children are still inspected for unfrozen literals deeper down.
+        def freeze_nested_literals(corrector, node)
+          literal_children(node).each do |child|
+            if explicitly_frozen_literal?(child)
+              freeze_nested_literals(corrector, child.receiver)
+            elsif freezable_nested_literal?(child)
+              autocorrect(corrector, child)
+            end
+          end
+        end
+
+        def freezable_nested_literal?(node)
+          return false if frozen_string_literal?(node)
+          return false if shareable_constant_value?(node)
+
+          mutable_literal?(node)
+        end
+
+        # Returns the child literals of an array or hash node that may
+        # themselves need freezing. For hashes, both keys and values are
+        # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because
+        # `.freeze` cannot be appended to their contents.
+        def literal_children(node)
+          case node.type
+          when :array
+            return [] if node.percent_literal?
+
+            node.children
+          when :hash
+            node.children.flat_map { |child| child.pair_type? ? child.children : [] }
+          else
+            []
+          end
+        end
+
+        def explicitly_frozen_literal?(node)
+          return false unless node.send_type? && node.method?(:freeze)
+
+          node.receiver && mutable_literal?(node.receiver)
+        end
+
+        def recursive?
+          cop_config.fetch('Recursive', false)
         end
 
         def mutable_literal?(value)

data/lib/rubocop/cop/style/parallel_assignment.rb

@@ -38,7 +38,7 @@ module RuboCop
           rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
-                    allowed_masign?(node.assignments, rhs_elements)
+                    allowed_masign?(node.assignments, rhs_elements) || contains_heredoc?(rhs)
 
           range = node.source_range.begin.join(rhs.source_range.end)
 
@@ -77,6 +77,13 @@ module RuboCop
           !node.array_type? || elements.any?(&:splat_type?)
         end
 
+        # Autocorrection splits the assignment into single assignments on
+        # consecutive lines, which would put following assignments into the
+        # heredoc body unless the heredoc bodies were moved along.
+        def contains_heredoc?(node)
+          node.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def assignment_corrector(node, rhs, order)
           if node.parent&.rescue_type?
             _assignment, modifier = *node.parent

data/lib/rubocop/cop/style/redundant_format.rb

@@ -108,6 +108,7 @@ module RuboCop
 
         def detect_unnecessary_fields(node)
           return unless node.first_argument&.str_type?
+          return if node.first_argument.heredoc?
 
           string = node.first_argument.value
           arguments = node.arguments[1..]