rubocop 1.90.0 → 1.92.0

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

@@ -35,6 +35,7 @@ module RuboCop
       #
       class SingleLineMethods < Base
         include Alignment
+        include EndlessMethodBodyHelp
         extend AutoCorrector
 
         MSG = 'Avoid single-line method definitions.'
@@ -67,10 +68,14 @@ module RuboCop
           return false if target_ruby_version < 3.0
           return false if disallow_endless_method_style?
           return false unless body_node
-          return false if body_node.basic_conditional? || body_node.parent.assignment_method? ||
-                          NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
+          return false if body_node.parent.assignment_method?
 
-          !body_node.type?(:begin, :kwbegin)
+          !unsupported_endless_method_body?(body_node) && endless_method_body?(body_node)
+        end
+
+        def unsupported_endless_method_body?(body_node)
+          body_node.basic_conditional? ||
+            NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES.include?(body_node.type)
         end
 
         def correct_to_multiline(corrector, node)
@@ -89,8 +94,8 @@ module RuboCop
 
         def correct_to_endless(corrector, node)
           receiver = "#{node.receiver.source}." if node.receiver
-          arguments = node.arguments.any? ? node.arguments.source : '()'
           body_source = method_body_source(node.body)
+          arguments = endless_arguments(node)
           replacement = "def #{receiver}#{node.method_name}#{arguments} = #{body_source}"
 
           corrector.replace(node, replacement)
@@ -138,6 +143,13 @@ module RuboCop
           !method_body.arguments.empty? && !method_body.comparison_method?
         end
 
+        def endless_arguments(node)
+          arguments = node.arguments
+          return '()' if arguments.none?
+
+          arguments.loc.begin ? arguments.source : "(#{arguments.source})"
+        end
+
         def disallow_endless_method_style?
           return true unless config.cop_enabled?('Style/EndlessMethod')
 

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

@@ -101,7 +101,7 @@ module RuboCop
                       'module (don\'t forget to require it) over `%<global>s`.'
         MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
 
-        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
+        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant -- merged into below, then frozen
           :$: => [:$LOAD_PATH],
           :$" => [:$LOADED_FEATURES],
           :$0 => [:$PROGRAM_NAME],

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

@@ -50,7 +50,33 @@ module RuboCop
         end
 
         def redundant_parentheses?(node)
-          style == :require_no_parentheses && parentheses?(node)
+          return false unless style == :require_no_parentheses && parentheses?(node)
+
+          arguments = node.block_node.arguments
+          !arguments_require_parentheses?(arguments) && !comment_inside_parentheses?(arguments)
+        end
+
+        def arguments_require_parentheses?(arguments)
+          arguments.each_descendant(:any_block, :hash).any? do |node|
+            !node.hash_type? || node.braces?
+          end
+        end
+
+        def comment_inside_parentheses?(arguments)
+          !leading_padding(arguments).source.strip.empty? ||
+            !trailing_padding(arguments).source.strip.empty?
+        end
+
+        def leading_padding(arguments)
+          first_argument = arguments.children.first
+
+          arguments.loc.begin.end.join(first_argument.source_range.begin)
+        end
+
+        def trailing_padding(arguments)
+          last_argument = arguments.children.last
+
+          last_argument.source_range.end.join(arguments.loc.end.begin)
         end
 
         def message(_node)
@@ -62,10 +88,8 @@ module RuboCop
         end
 
         def unwanted_parentheses_corrector(corrector, node)
-          args_loc = node.loc
-
-          corrector.replace(args_loc.begin, '')
-          corrector.remove(args_loc.end)
+          corrector.remove(node.loc.begin.join(leading_padding(node)))
+          corrector.remove(trailing_padding(node).join(node.loc.end))
         end
 
         def stabby_lambda_with_args?(node)

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

@@ -160,7 +160,9 @@ module RuboCop
         end
 
         def adjust_str_literal(part)
-          if single_quoted?(part)
+          if file_keyword?(part)
+            "\#{#{part.source}}"
+          elsif single_quoted?(part)
             part.value.gsub(/(\\|"|#\{|#@|#\$)/, '\\\\\&')
           elsif double_quoted?(part)
             # Reuse the source as written - rebuilding it from the value via
@@ -178,12 +180,16 @@ module RuboCop
           end
         end
 
+        def file_keyword?(str_node)
+          str_node.source == '__FILE__' && !str_node.parent.dstr_type?
+        end
+
         def single_quoted?(str_node)
-          str_node.source.start_with?("'")
+          str_node.loc.begin && str_node.source.start_with?("'")
         end
 
         def double_quoted?(str_node)
-          str_node.source.start_with?('"')
+          str_node.loc.begin && str_node.source.start_with?('"')
         end
 
         def mode

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

@@ -10,6 +10,10 @@ module RuboCop
       #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
+      #   It is also unsafe because constants that the class body resolves through its
+      #   ancestors (e.g. one provided by an included module) fall out of scope inside
+      #   the block.
+      #
       # @example
       #   # bad
       #   class Person < Struct.new(:first_name, :last_name)
@@ -39,6 +43,7 @@ module RuboCop
 
         def on_class(node)
           return unless struct_constructor?(node.parent_class)
+          return if defines_constants?(node.body)
 
           add_offense(node.parent_class) do |corrector|
             corrector.remove(
@@ -58,6 +63,15 @@ module RuboCop
 
         private
 
+        # Constants, including nested classes and modules, are scoped to the class when they
+        # are defined in a class body, but leak into the enclosing namespace once moved into a
+        # `Struct.new` block, so such a class cannot be rewritten as an assignment.
+        def defines_constants?(class_body)
+          return false unless class_body
+
+          class_body.each_node(:casgn, :class, :module).any?
+        end
+
         def correct_parent(parent, corrector)
           if parent.block_type?
             corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))

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

@@ -76,6 +76,9 @@ module RuboCop
 
         def on_super(super_node)
           return unless (def_node = find_def_node(super_node))
+          # Zsuper passes a destructured argument as the original value, while
+          # `argument_list` flattens it into its parts.
+          return if def_node.arguments.any?(&:mlhs_type?)
 
           def_node_args = def_node.arguments.argument_list
           super_args = preprocess_super_args(super_node.arguments)

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

@@ -142,9 +142,11 @@ module RuboCop
         include RangeHelp
         include AllowedMethods
         include AllowedPattern
+        include PatternMatchingHelp
         extend AutoCorrector
 
         MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
+        MSG_LAMBDA_LITERAL = 'Use `lambda(&:%<method>s)` instead of %<original>s.'
         SUPER_TYPES = %i[super zsuper].freeze
         LAMBDA_OR_PROC = %i[lambda proc].freeze
 
@@ -174,6 +176,8 @@ module RuboCop
               return if proc_node?(dispatch_node)
               return if LAMBDA_OR_PROC.include?(dispatch_node.method_name)
             end
+            # A pattern accepts a lambda literal, but not `lambda(&:foo)`.
+            return if in_pattern?(node)
             return if unsafe_hash_usage?(dispatch_node)
             return if unsafe_array_usage?(dispatch_node)
             return if allowed_method_name?(dispatch_node.method_name)
@@ -207,12 +211,26 @@ module RuboCop
         end
 
         def register_offense(node, method_name, block_method_name)
-          block_start = node.loc.begin.begin_pos
-          block_end = node.loc.end.end_pos
-          range = range_between(block_start, block_end)
-          message = format(MSG, method: method_name, block_method: block_method_name)
+          range = if node.send_node.lambda_literal?
+                    node.source_range
+                  else
+                    node.loc.begin.begin.join(node.loc.end.end)
+                  end
+          message = message(node, method_name, block_method_name)
 
-          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
+          add_offense(range, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def message(node, method_name, block_method_name)
+          if node.send_node.lambda_literal?
+            original = node.single_line? ? "`#{node.source}`" : 'a lambda literal with a block'
+
+            format(MSG_LAMBDA_LITERAL, method: method_name, original: original)
+          else
+            format(MSG, method: method_name, block_method: block_method_name)
+          end
         end
 
         def autocorrect(corrector, node)

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

@@ -58,6 +58,7 @@ module RuboCop
         include SafeAssignment
         include ConfigurableEnforcedStyle
         include SurroundingSpace
+        include ReparsedEquivalence
         extend AutoCorrector
 
         VARIABLE_TYPES = AST::Node::VARIABLES
@@ -101,7 +102,8 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition) ||
+                         verified_by_reparse([condition]).empty?)
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -218,6 +220,26 @@ module RuboCop
           end
         end
 
+        # Whatever binds looser than the ternary operator (`n += 1`, `a rescue b`,
+        # a nested ternary, `yield a`, several statements, ...) changes
+        # meaning without the parentheses, so their removal is verified by
+        # reparsing.
+        def apply_reparse_correction(corrector, condition)
+          correct_parenthesized(corrector, condition)
+        end
+
+        # The removed parentheses are the only expected difference.
+        def normalize_reparsed_ast(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| normalize_reparsed_ast(child) }
+          if node.begin_type? && children.one? && children.first.is_a?(::Parser::AST::Node)
+            children.first
+          else
+            node.updated(nil, children)
+          end
+        end
+
         def correct_unparenthesized(corrector, condition)
           corrector.wrap(condition, '(', ')')
         end

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

@@ -64,7 +64,7 @@ module RuboCop
 
         MSG = 'Useless trailing comma present in block arguments.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- a trailing comma needs an explicit parameter list
           # lambda literal (`->`) never has block arguments.
           return if node.send_node.lambda_literal?
           return unless useless_trailing_comma?(node)

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

@@ -35,19 +35,20 @@ module RuboCop
 
         MSG = 'Do not use trailing `_`s in parallel assignment. Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        ARRAY_OPENING = '['
         DISALLOW = %i[lvasgn splat].freeze
         private_constant :DISALLOW
 
         def on_masgn(node)
-          ranges = unneeded_ranges(node)
-
-          ranges.each do |range|
+          unneeded_ranges(node).each do |range, replacement|
+            closing = replacement == ARRAY_OPENING ? ']' : ''
             good_code = node.source
             offset = range.begin_pos - node.source_range.begin_pos
-            good_code[offset, range.size] = ''
+            good_code[offset, range.size] = replacement
 
-            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
-              corrector.remove(range)
+            add_offense(range, message: format(MSG, code: "#{good_code}#{closing}")) do |corrector|
+              corrector.replace(range, replacement)
+              corrector.insert_after(node, closing) unless closing.empty?
             end
           end
         end
@@ -115,9 +116,12 @@ module RuboCop
 
           return unused_range(node, mlhs_node) if unused_variables_only?(first_offense, variables)
 
-          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
-
-          range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+          range = if Util.parentheses?(mlhs_node)
+                    range_for_parentheses(first_offense, mlhs_node)
+                  else
+                    range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
+                  end
+          [range, '']
         end
 
         def children_offenses(variables)
@@ -129,17 +133,17 @@ module RuboCop
         end
 
         def unused_range(node, mlhs_node)
-          start_range = mlhs_node.source_range.begin_pos
-
           # `node` can be an `mlhs` when recursing into a nested destructuring
-          # group; only a `masgn` has a right-hand side to anchor against.
-          end_range = if node.masgn_type?
-                        node.rhs.source_range.begin_pos
-                      else
-                        mlhs_node.source_range.end_pos
-                      end
-
-          range_between(start_range, end_range)
+          # group. Removing the group could leave a dangling comma or put
+          # something after a splat, so it is collapsed into a single `_`,
+          # which the parent group handles in turn.
+          return [mlhs_node.source_range, UNDERSCORE] unless node.masgn_type?
+
+          rhs = node.rhs
+          range = range_between(mlhs_node.source_range.begin_pos, rhs.source_range.begin_pos)
+
+          # `_, _ = 1, 2` cannot become `1, 2`, so the values become an array literal.
+          [range, rhs.array_type? && !rhs.bracketed? ? ARRAY_OPENING : '']
         end
 
         def range_for_parentheses(offense, left)

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

@@ -59,7 +59,7 @@ module RuboCop
         private
 
         def non_eligible_body?(body)
-          body&.conditional? || super
+          body&.conditional? || body&.kwbegin_type? || super
         end
       end
     end

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

@@ -104,7 +104,7 @@ module RuboCop
                     valid_yoda?(node)
 
           add_offense(node) do |corrector|
-            corrector.replace(actual_code_range(node), corrected_code(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -138,22 +138,37 @@ module RuboCop
           format(MSG, source: node.source)
         end
 
-        def corrected_code(node)
-          lhs = node.receiver
-          rhs = node.first_argument
-
-          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
+        def autocorrect(corrector, node)
+          if constant_portion?(node.first_argument)
+            move_argument_to_front(corrector, node)
+          else
+            move_receiver_to_back(corrector, node)
+          end
         end
 
         def constant_portion?(node)
           node.recursive_literal? || node.const_type?
         end
 
-        def actual_code_range(node)
-          range_between(node.source_range.begin_pos, node.source_range.end_pos)
+        def move_argument_to_front(corrector, node)
+          receiver = node.receiver
+
+          replacement = "#{node.first_argument.source} #{reverse_comparison(node)} "
+
+          corrector.insert_before(receiver, replacement)
+          corrector.remove(receiver.source_range.end.join(node.source_range.end))
         end
 
-        def reverse_comparison(operator)
+        def move_receiver_to_back(corrector, node)
+          argument = node.first_argument
+
+          corrector.remove(node.source_range.begin.join(argument.source_range.begin))
+          corrector.insert_after(argument, " #{reverse_comparison(node)} #{node.receiver.source}")
+        end
+
+        def reverse_comparison(node)
+          operator = node.method_name
+
           REVERSE_COMPARISON.fetch(operator.to_s, operator)
         end
 

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

@@ -43,6 +43,9 @@ module RuboCop
         MSG = 'Non-literal operand (`%<source>s`) should be first.'
 
         RESTRICT_ON_SEND = %i[* + & | ^].freeze
+        ARGUMENT_ONLY_TYPES = %i[
+          splat block_pass forwarded_args forwarded_restarg forwarded_kwrestarg
+        ].freeze
 
         def on_new_investigation
           @offended_nodes = nil
@@ -68,13 +71,19 @@ module RuboCop
         private
 
         def yoda_expression_constant?(lhs, rhs)
-          constant_portion?(lhs) && !constant_portion?(rhs)
+          constant_portion?(lhs) && !constant_portion?(rhs) && operand?(rhs)
         end
 
         def constant_portion?(node)
           node.type?(:numeric, :const)
         end
 
+        def operand?(node)
+          return false if node.hash_type? && !node.braces?
+
+          !node.type?(*ARGUMENT_ONLY_TYPES)
+        end
+
         def supported_operators
           @supported_operators ||= Array(cop_config['SupportedOperators']).freeze
         end

data/lib/rubocop/cop/style.rb

@@ -63,7 +63,6 @@ module RuboCop
       register_cop :DocumentationMethod, "#{__dir__}/style/documentation_method"
       register_cop :Documentation, "#{__dir__}/style/documentation"
       register_cop :DocumentDynamicEvalDefinition, "#{__dir__}/style/document_dynamic_eval_definition"
-      register_cop :DoubleCopDisableDirective, "#{__dir__}/style/double_cop_disable_directive"
       register_cop :DoubleNegation, "#{__dir__}/style/double_negation"
       register_cop :EachForSimpleLoop, "#{__dir__}/style/each_for_simple_loop"
       register_cop :EachWithObject, "#{__dir__}/style/each_with_object"

data/lib/rubocop/cop/team.rb

@@ -178,7 +178,7 @@ module RuboCop
         elsif defer_corrections
           @updated_source = new_source
         else
-          File.write(processed_source.file_path, new_source)
+          RuboCop::Util.replace_file_contents(processed_source.file_path, new_source)
         end
       end
 
@@ -342,20 +342,25 @@ module RuboCop
       end
 
       def each_corrector(report)
-        skips = Set.new
+        applied = []
         report.cop_reports.each do |cop_report|
-          cop = cop_report.cop
+          cop_class = cop_report.cop.class
           corrector = cop_report.corrector
 
           next if corrector.nil? || corrector.empty?
-          next if skips.include?(cop.class)
+          next if applied.any? { |other| autocorrect_incompatible?(cop_class, other) }
 
           yield corrector
 
-          skips.merge(cop.class.autocorrect_incompatible_with)
+          applied << cop_class
         end
       end
 
+      def autocorrect_incompatible?(cop_class, other)
+        cop_class.autocorrect_incompatible_with.include?(other) ||
+          other.autocorrect_incompatible_with.include?(cop_class)
+      end
+
       def suppress_clobbering
         yield
       rescue ::Parser::ClobberingError

data/lib/rubocop/cop/util.rb

@@ -63,7 +63,7 @@ module RuboCop
           end
         else
           # Use a block version to avoid allocating enumerators.
-          node.each_descendant do # rubocop:disable Lint/UnreachableLoop
+          node.each_descendant do # rubocop:disable Lint/UnreachableLoop -- the block form avoids allocating an enumerator
             return true
           end
         end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def used?
-          (!reassigned? && @variable.captured_by_block?) || @referenced
+          (!reassigned? && @variable.captured_by_block? && @variable.referenced?) || @referenced
         end
 
         def regexp_named_capture?

data/lib/rubocop/cop/variable_force/variable.rb

@@ -67,7 +67,8 @@ module RuboCop
 
             break if !assignment.branch || assignment.branch == reference.branch
 
-            unless assignment.branch.may_run_incompletely?
+            unless assignment.branch.may_run_incompletely? ||
+                   exception_may_reach?(assignment.branch, node)
               (consumed_branches ||= Set.new) << assignment.branch
             end
           end
@@ -83,6 +84,18 @@ module RuboCop
           covers?(conditional, reference_node) && !covers?(conditional.condition, reference_node)
         end
 
+        # A branch nested in the main body of `begin` can be cut short by an exception
+        # too. An earlier assignment in it is visible to a reference in the `rescue` or
+        # `ensure` clause, or after a `rescue` that handles the exception.
+        def exception_may_reach?(branch, reference_node)
+          branch.each_ancestor.any? do |ancestor|
+            next false unless ancestor.may_run_incompletely?
+            next false if covers?(ancestor.child_node, reference_node)
+
+            ancestor.control_node.rescue_type? || covers?(ancestor.control_node, reference_node)
+          end
+        end
+
         def modifier_conditional_of(node)
           node.each_ancestor(:if, :while, :until).find do |conditional|
             conditional.modifier_form? && covers?(conditional.condition, node)

data/lib/rubocop/cops_documentation_generator.rb

@@ -20,6 +20,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     safety:                ->(data) { safety_object(data.safety_objects, data.cop) },
     examples:              ->(data) { examples(data.example_objects, data.cop) },
     configuration:         ->(data) { configurations(data.cop.department, data.cop, data.config) },
+    preview:               ->(data) { preview_defaults(data.cop) },
     references:            ->(data) { references(data.cop, data.see_objects) }
   }.freeze
 
@@ -194,7 +195,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def configurations(department, cop, cop_config)
     header = ['Name', 'Default value', 'Configurable values']
     configs = cop_config.each_key.reject do |key|
-      key == 'AllowMultipleStyles' ||
+      key == 'AllowMultipleStyles' || key == 'Preview' ||
         (key != 'SupportedTypes' && key.start_with?('Supported'))
     end
     return '' if configs.empty?
@@ -209,6 +210,22 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cop_subsection('Configurable attributes', cop) + to_table(header, content)
   end
 
+  def preview_defaults(cop)
+    cop_config = config.for_cop(cop)
+    preview = cop_config['Preview']
+    return '' unless preview.is_a?(Hash)
+
+    header = ['Name', 'Current default', 'Preview default']
+    content = preview.map do |name, value|
+      [name, format_table_value(cop_config[name]), format_table_value(value)]
+    end
+
+    cop_subsection('Preview defaults', cop) +
+      'These defaults apply under xref:versioning.adoc#preview[Preview] and are ' \
+      "expected to become the regular defaults in the next major release.\n\n" +
+      to_table(header, content)
+  end
+
   def configuration_name(department, name)
     return name unless name == 'AllowMultilineFinalElement'
 
@@ -389,7 +406,11 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def cop_status(status)
     return 'Disabled' unless status
 
-    status == 'pending' ? 'Pending' : 'Enabled'
+    case status
+    when 'pending' then 'Pending'
+    when 'preview' then 'Preview'
+    else 'Enabled'
+    end
   end
 
   # HTML anchor are somewhat limited in what characters they can contain, just