rubocop 1.71.1 → 1.92.1

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

@@ -17,39 +17,81 @@ module RuboCop
       class MultilineIfModifier < Base
         include StatementModifier
         include Alignment
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Favor a normal %<keyword>s-statement over a modifier ' \
               'clause in a multiline statement.'
 
         def on_if(node)
+          return if part_of_ignored_node?(node)
           return unless node.modifier_form? && node.body.multiline?
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
-            corrector.replace(node, to_normal_if(node))
+            autocorrect(corrector, node)
           end
+          ignore_node(node)
         end
 
         private
 
-        def to_normal_if(node)
+        def autocorrect(corrector, node)
+          condition_heredoc, body_heredoc = [node.condition, node.body].map do |part|
+            next unless (range = heredoc_after(part, node))
+
+            corrector.remove(range)
+            range.source.chomp
+          end
+          corrector.replace(node, to_normal_if(node, condition_heredoc, body_heredoc))
+        end
+
+        # Heredocs opened on the modifier line have their bodies after it, so
+        # they are moved along with the part of the `if` they belong to.
+        def heredoc_after(part, node)
+          ranges = part.each_node(:any_str).select(&:heredoc?).map do |heredoc|
+            heredoc.loc.heredoc_body.join(heredoc.loc.heredoc_end)
+          end
+          ranges.select! { |range| range.line > node.last_line }
+          return if ranges.empty?
+
+          range_by_whole_lines(ranges.reduce(:join), include_final_newline: true)
+        end
+
+        def to_normal_if(node, condition_heredoc, body_heredoc)
           indented_body = indented_body(node.body, node)
           condition = "#{node.keyword} #{node.condition.source}"
           indented_end = "#{offset(node)}end"
 
-          [condition, indented_body, indented_end].join("\n")
+          lines = [condition, condition_heredoc, indented_body, body_heredoc, indented_end]
+          lines.compact.join("\n")
         end
 
         def indented_body(body, node)
           body_source = "#{offset(node)}#{body.source}"
-          body_source.each_line.map do |line|
-            if line == "\n"
+          verbatim_lines = verbatim_lines_in(body)
+          body_source.each_line.with_index(body.first_line).map do |line, line_number|
+            if line == "\n" || verbatim_lines.include?(line_number)
               line
             else
               line.sub(/^\s{#{offset(node).length}}/, indentation(node))
             end
           end.join
         end
+
+        def verbatim_lines_in(body)
+          body.each_node(:any_str).filter_map { |str| verbatim_line_range(str) }.flat_map(&:to_a)
+        end
+
+        # The indentation of a line that starts inside a string is part of the
+        # string. Only squiggly heredocs strip it from their bodies, and a `<<`
+        # terminator has to stay at the start of its line.
+        def verbatim_line_range(str)
+          if str.heredoc?
+            str.loc.heredoc_body.line..str.loc.heredoc_end.line unless str.source.start_with?('<<~')
+          elsif str.loc?(:begin) && str.loc?(:end)
+            (str.first_line + 1)..str.last_line
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of the `then` keyword in multi-line if statements.
+      # Checks for uses of the `then` keyword in multi-line `if` statements.
+      # In multi-line `if` statements, `then` is redundant because the newline
+      # already separates the condition from the body.
       #
       # @example
       #   # bad
@@ -21,8 +23,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
-
         MSG = 'Do not use `then` for multi-line `%<keyword>s`.'
 
         def on_normal_if_unless(node)
@@ -36,7 +36,13 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+          node.multiline? && own_then?(node) && node.loc.begin.line != node.if_branch&.loc&.line
+        end
+
+        # Prism gives an `elsif` with no `then` of its own the previous branch's `then` location,
+        # which lies outside the node.
+        def own_then?(node)
+          node.then? && node.source_range.contains?(node.loc.begin)
         end
       end
     end

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

@@ -50,10 +50,17 @@ module RuboCop
         # Requires `then` for write `in` and its body on the same line.
         def require_then?(in_pattern_node)
           return true unless in_pattern_node.pattern.single_line?
+          return true if ends_with_endless_range?(in_pattern_node.pattern)
           return false unless in_pattern_node.body
 
           same_line?(in_pattern_node, in_pattern_node.body)
         end
+
+        def ends_with_endless_range?(node)
+          node.each_node(:range).any? do |range|
+            range.end.nil? && range.source_range.end_pos == node.source_range.end_pos
+          end
+        end
       end
     end
   end

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

@@ -65,10 +65,16 @@ module RuboCop
           if style == :keyword
             rhs.begin_type?
           else
-            rhs.kwbegin_type?
+            # A `begin` block with `rescue`/`ensure` cannot be expressed with
+            # parentheses, so wrapping it in `(` and `)` is not possible.
+            rhs.kwbegin_type? && !contains_rescue_or_ensure?(rhs)
           end
         end
 
+        def contains_rescue_or_ensure?(node)
+          node.each_child_node(:rescue, :ensure).any?
+        end
+
         def keyword_autocorrect(node, corrector)
           node_buf = node.source_range.source_buffer
           corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))

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

@@ -27,6 +27,7 @@ module RuboCop
         def on_def(node)
           return unless node.arguments?
           return if opening_line(node) == closing_line(node)
+          return if node.arguments.any?(&:multiline?)
           return if correction_exceeds_max_line_length?(node)
           return unless (begin_of_arguments = node.arguments.loc.begin)
 
@@ -38,7 +39,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, node, begin_of_arguments)
           arguments = node.arguments
           joined_arguments = arguments.map(&:source).join(', ')
@@ -50,30 +51,23 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          arguments_range = arguments_range(node)
-          # If the method name isn't on the same line as def, move it directly after def
+          arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
+          # If the method name isn't on the same line as `def`, pull the name and
+          # the opening parenthesis up next to `def` so the collapsed signature
+          # stays on a single line and remains valid Ruby.
           if arguments_range.first_line != opening_line(node)
-            corrector.remove(node.loc.name)
-            corrector.insert_after(node.loc.keyword, " #{node.loc.name.source}")
+            prefix_range = range_between(node.loc.keyword.end_pos, begin_of_arguments.begin_pos)
+            corrector.replace(prefix_range, " #{prefix_range.source.strip}")
           end
 
           corrector.remove(arguments_range)
           corrector.insert_after(begin_of_arguments, joined_arguments)
         end
-        # rubocop:enable Metrics/AbcSize
 
         def last_line_source_of_arguments(arguments)
           processed_source[arguments.last_line - 1].strip
         end
 
-        def arguments_range(node)
-          range = range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-
-          range_with_surrounding_space(range, side: :left)
-        end
-
         def opening_line(node)
           node.first_line
         end
@@ -83,19 +77,18 @@ module RuboCop
         end
 
         def correction_exceeds_max_line_length?(node)
-          indentation_width(node) + definition_width(node) > max_line_length
-        end
+          return false unless max_line_length
 
-        def indentation_width(node)
-          processed_source.line_indentation(node.source_range.line)
+          node.source_range.column + definition_width(node) > max_line_length
         end
 
         def definition_width(node)
-          node.source_range.begin.join(node.arguments.source_range.end).length
-        end
+          # Measure the collapsed single-line width the autocorrect would
+          # produce, not the multi-line source length, so a signature that
+          # would fit on one line is not skipped.
+          signature = node.source_range.begin.join(node.arguments.source_range.end).source
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 120
+          signature.gsub(/\s+/, ' ').length
         end
       end
     end

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

@@ -7,7 +7,8 @@ module RuboCop
       #
       # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
       # multiline ternary operator expression, it will be autocorrected to single-line
-      # ternary operator. The same is true for `break`, `next`, and method call.
+      # ternary operator. The same is true for `break`, `next`, `yield`, `super`,
+      # `defined?` without parentheses, and method call.
       #
       # @example
       #   # bad
@@ -39,7 +40,7 @@ module RuboCop
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
         MSG_SINGLE_LINE = 'Avoid multi-line ternary operators, use single-line instead.'
-        SINGLE_LINE_TYPES = %i[return break next send csend].freeze
+        SINGLE_LINE_TYPES = %i[return break next send csend super yield].freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -90,7 +91,10 @@ module RuboCop
         end
 
         def enforce_single_line_ternary_operator?(node)
-          SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
+          return false unless (parent = node.parent)
+          return !parent.parenthesized? if parent.defined_type?
+
+          SINGLE_LINE_TYPES.include?(parent.type) && !use_assignment_method?(parent)
         end
 
         def use_assignment_method?(node)

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

@@ -50,10 +50,17 @@ module RuboCop
           unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
             return true
           end
+          return true if ends_with_endless_range?(when_node.conditions.last)
           return false unless when_node.body
 
           same_line?(when_node, when_node.body)
         end
+
+        def ends_with_endless_range?(node)
+          node.each_node(:range).any? do |range|
+            range.end.nil? && range.source_range.end_pos == node.source_range.end_pos
+          end
+        end
       end
     end
   end

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

@@ -70,48 +70,59 @@ module RuboCop
           (send $_ :== ${lvar call})
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_or(node)
-          root_of_or_node = root_of_or_node(node)
-          return unless node == root_of_or_node
+          return unless node == root_of_or_node(node)
           return unless nested_comparison?(node)
-
-          return unless (variable, values = find_offending_var(node))
+          return unless (variable, values, skipped = find_offending_var(node))
           return if values.size < comparisons_threshold
 
           range = offense_range(values)
+          # Bail when an allowed method comparison sits between the collected
+          # values: collapsing them into a single `include?` would drop it.
+          return if skipped_within_range?(skipped, range)
 
           add_offense(range) do |corrector|
-            elements = values.map(&:source).join(', ')
-            argument = variable.lvar_type? ? variable_name(variable) : variable.source
-            prefer_method = "[#{elements}].include?(#{argument})"
-
-            corrector.replace(range, prefer_method)
+            corrector.replace(range, preferred_method(variable, values))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def find_offending_var(node, variables = Set.new, values = [])
+        def skipped_within_range?(skipped, range)
+          skipped.any? { |node_part| range.contains?(node_part.source_range) }
+        end
+
+        def preferred_method(variable, values)
+          elements = values.map(&:source).join(', ')
+          argument = variable.lvar_type? ? variable_name(variable) : variable.source
+          "[#{elements}].include?(#{argument})"
+        end
+
+        def find_offending_var(node, variables = Set.new, values = [], skipped = [])
           if node.or_type?
-            find_offending_var(node.lhs, variables, values)
-            find_offending_var(node.rhs, variables, values)
+            find_offending_var(node.lhs, variables, values, skipped)
+            find_offending_var(node.rhs, variables, values, skipped)
           elsif simple_double_comparison?(node)
             return
-          elsif (var, obj = simple_comparison(node))
-            return if allow_method_comparison? && obj.call_type?
+          elsif (comparison = simple_comparison(node))
+            collect_comparison(node, comparison, variables, values, skipped)
+          end
 
-            variables << var
-            return if variables.size > 1
+          [variables.first, values, skipped] if variables.any?
+        end
 
-            values << obj
+        def collect_comparison(node, comparison, variables, values, skipped)
+          var, obj = comparison
+          if allow_method_comparison? && obj.call_type?
+            skipped << node
+            return
           end
 
-          [variables.first, values] if variables.any?
+          variables << var
+          return if variables.size > 1
+
+          values << obj
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def offense_range(values)
           values.first.parent.source_range.begin.join(values.last.parent.source_range.end)

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
@@ -70,6 +89,9 @@ module RuboCop
       #     end
       #   end.freeze
       #
+      #   # good - `Data.define` declares an immutable value type
+      #   CONST = Data.define(:foo, :bar)
+      #
       # @example
       #   # Magic comment - shareable_constant_value: literal
       #
@@ -124,8 +146,15 @@ module RuboCop
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
+        # With `Recursive: true`, `.freeze` is appended to a nested literal. When the literal
+        # is the last element and spans multiple lines, the trailing comma lands between the literal
+        # and the `.freeze` appended in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::HashAsLastArrayItem, Style::TrailingCommaInArrayLiteral, Style::TrailingCommaInHashLiteral]
+        end
+
         def on_casgn(node)
-          if node.expression.nil? # This is only the case for `CONST += ...` or similarg66
+          if node.expression.nil? # This is only the case for `CONST += ...` or similar
             parent = node.parent
             return unless parent.or_asgn_type? # We only care about `CONST ||= ...`
 
@@ -138,31 +167,55 @@ 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
 
         def strict_check(value)
+          return if value.assignment?
           return if immutable_literal?(value)
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)
+          return if parenthesized_immutable_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 +224,84 @@ 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
+
+          return expand_omitted_hash_value(corrector, node.parent) if omitted_hash_value?(node)
+
+          wrap_for_freeze(corrector, node, expr)
+          corrector.insert_after(expr, '.freeze')
+
+          freeze_nested_literals(corrector, node) if recursive?
+        end
+
+        def omitted_hash_value?(node)
+          node.parent&.pair_type? && node.parent.value_omission?
+        end
+
+        def expand_omitted_hash_value(corrector, pair)
+          key = pair.key.value
+
+          corrector.replace(pair, "#{key}: #{key}.freeze")
+        end
+
+        def wrap_for_freeze(corrector, node, expr)
+          if node.array_type? && !node.bracketed?
             corrector.wrap(expr, '[', ']')
+          elsif node.hash_type? && !node.braces?
+            corrector.wrap(expr, '{ ', ' }')
           elsif requires_parentheses?(node)
             corrector.wrap(expr, '(', ')')
           end
+        end
 
-          corrector.insert_after(expr, '.freeze')
+        # 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. Splat elements are
+        # skipped because the splatted object is not stored in the array.
+        def literal_children(node)
+          case node.type
+          when :array
+            return [] if node.percent_literal?
+
+            node.children.reject(&:splat_type?)
+          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)
@@ -196,12 +320,30 @@ module RuboCop
           recent_shareable_value? node
         end
 
+        def parenthesized_immutable_value?(value)
+          return false if !value.begin_type? || !value.children.one?
+
+          inner = value.children.first
+
+          !inner.assignment? && !strict_check(inner)
+        end
+
         def frozen_regexp_or_range_literals?(node)
           target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)
-          node.range_type? || (node.send_type? && node.loc.dot.nil?)
+          if node.range_type? || node.operator_keyword? || unparenthesized_method_call?(node)
+            return true
+          end
+
+          node.if_type? && node.ternary?
+        end
+
+        def unparenthesized_method_call?(node)
+          return false unless node.call_type?
+
+          node.loc.dot.nil? || (node.arguments.any? && !node.parenthesized?)
         end
 
         def correct_splat_expansion(corrector, expr, splat_value)
@@ -225,6 +367,8 @@ module RuboCop
             (const _ _)
             (send (const {nil? cbase} :Struct) :new ...)
             (block (send (const {nil? cbase} :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (block (send (const {nil? cbase} :Data) :define ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})

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

@@ -46,7 +46,7 @@ module RuboCop
           @corrected_nodes = nil
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize,Metrics/CyclomaticComplexity
         def on_if(node)
           return unless if_else?(node)
           return unless (condition = unwrap_begin_nodes(node.condition))
@@ -64,7 +64,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity
 
         private
 
@@ -119,7 +118,8 @@ module RuboCop
           if node.ternary?
             node.if_branch
           else
-            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
+            if_start = node.loc.begin || node.condition.source_range
+            range_between(if_start.end_pos, node.loc.else.begin_pos)
           end
         end