rubocop 1.71.1 → 1.92.0

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

@@ -12,6 +12,11 @@ module RuboCop
       #   exception class handle `StandardError` and its subclasses,
       #   but not `Exception` and its subclasses.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, indirect inheritance is also detected: a class whose parent
+      # (defined anywhere in the project) ultimately inherits from `Exception`
+      # is reported, without autocorrection.
+      #
       # @example EnforcedStyle: standard_error (default)
       #   # bad
       #
@@ -39,9 +44,11 @@ module RuboCop
       #   C = Class.new(RuntimeError)
       class InheritException < Base
         include ConfigurableEnforcedStyle
+        include ProjectIndexHelp
         extend AutoCorrector
 
         MSG = 'Inherit from `%<prefer>s` instead of `Exception`.'
+        INDIRECT_MSG = 'Inherit from `%<prefer>s` instead of `Exception` (inherited via `%<via>s`).'
         PREFERRED_BASE_CLASS = {
           runtime_error: 'RuntimeError',
           standard_error: 'StandardError'
@@ -57,13 +64,20 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          return unless node.parent_class && exception_class?(node.parent_class)
-          return if inherit_exception_class_with_omitted_namespace?(node)
-
-          message = message(node.parent_class)
-
-          add_offense(node.parent_class, message: message) do |corrector|
-            corrector.replace(node.parent_class, preferred_base_class)
+          parent_class = node.parent_class
+          return unless parent_class
+
+          if exception_class?(parent_class)
+            return if inherit_exception_class_with_omitted_namespace?(node)
+
+            add_offense(parent_class, message: message(parent_class)) do |corrector|
+              corrector.replace(parent_class, preferred_base_class)
+            end
+          elsif (via = inherits_exception_via(parent_class))
+            # No autocorrection: the `Exception` inheritance lives at another
+            # class' definition site, possibly in another file.
+            message = format(INDIRECT_MSG, prefer: preferred_base_class, via: via)
+            add_offense(parent_class, message: message)
           end
         end
 
@@ -88,6 +102,38 @@ module RuboCop
           class_node.const_name == 'Exception'
         end
 
+        # When `AllCops/UseProjectIndex` is enabled, indirect inheritance is
+        # detected by walking the parent's indexed ancestry: `Exception` itself
+        # is not indexed, so a chain ending in it shows up as an ancestor whose
+        # superclass reference is unresolved and literally named `Exception`.
+        # Returns the name of that ancestor, or `nil`.
+        def inherits_exception_via(parent_class)
+          return nil unless project_index && parent_class.const_type?
+
+          declaration = resolve_constant_in_index(parent_class)
+          return nil unless declaration.is_a?(Rubydex::Class)
+
+          exception_ancestor(declaration)&.name
+        rescue StandardError
+          nil
+        end
+
+        def exception_ancestor(declaration)
+          declaration.ancestors.find do |ancestor|
+            ancestor.is_a?(Rubydex::Class) && exception_superclass_reference?(ancestor)
+          end
+        end
+
+        def exception_superclass_reference?(ancestor)
+          ancestor.definitions.any? do |definition|
+            next false unless definition.is_a?(Rubydex::ClassDefinition)
+
+            superclass = definition.superclass
+            superclass.is_a?(Rubydex::UnresolvedConstantReference) &&
+              superclass.name.delete_prefix('::') == 'Exception'
+          end
+        end
+
         def inherit_exception_class_with_omitted_namespace?(class_node)
           return false if class_node.parent_class.namespace&.cbase_type?
 

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

@@ -24,8 +24,25 @@ 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)
+          check(node)
+        end
+
+        # A multiline single-quoted string is parsed as a `dstr` of `str` segments, so it
+        # is not covered by `on_str`. Inspect single-quoted `dstr`s here; double-quoted
+        # interpolation is also a `dstr`, hence the delimiter check.
+        def on_dstr(node)
+          # A heredoc is also a `dstr`, but its `loc` is a `Parser::Source::Map::Heredoc`
+          # with no `begin`, so bail before touching it.
+          return if heredoc?(node)
+
+          check(node) if node.loc.begin&.source == "'"
+        end
+
+        private
+
+        # rubocop:disable-next Metrics/CyclomaticComplexity
+        def check(node)
           return if node.parent&.regexp_type?
           return unless /(?<!\\)#\{.*\}/.match?(node.source)
           return if heredoc?(node)
@@ -34,9 +51,6 @@ module RuboCop
 
           add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        private
 
         def autocorrect(corrector, node)
           starting_token, ending_token = if node.source.include?('"')
@@ -54,9 +68,14 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+          double_quoted_string = if node.source.include?('"')
+                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
+                                 else
+                                   node.source.gsub(/\A'|'\z/, '"')
+                                 end
 
-          parse(double_quoted_string).valid_syntax?
+          processed_source = parse(double_quoted_string)
+          processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
       end
     end

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

@@ -42,7 +42,7 @@ module RuboCop
           end
 
           add_offense(node) do |corrector|
-            corrector.replace(node, node.first_argument.source.delete('&'))
+            corrector.replace(node, node.first_argument.source.delete_prefix('&'))
           end
         end
       end

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,30 +37,109 @@ 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 void_value_expression?(node.rhs)
+
+            corrector.replace(node, node.rhs.source)
+          end
+        end
+
+        def on_or(node)
+          return unless node.lhs.falsey_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 void_value_expression?(node.rhs)
+
+            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
+
+        # rubocop:disable-next 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|
+              next if orphans_loop_control_keyword?(node)
+
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_while_post on_while
 
         def on_until(node)
-          return if condition(node).false_type?
+          return if node.condition.source == 'false'
 
-          check_for_literal(node)
+          if node.condition.falsey_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.replace(node.condition, 'false')
+            end
+          elsif node.condition.truthy_literal?
+            add_offense(node.condition) do |corrector|
+              corrector.remove(node)
+            end
+          end
+        end
+
+        # rubocop:disable-next 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|
+              next if orphans_loop_control_keyword?(node)
+
+              corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
+            end
+          end
         end
-        alias on_until_post on_until
 
         def on_case(case_node)
-          if case_node.condition
+          if (cond = case_node.condition)
+            return if !cond.falsey_literal? && !cond.truthy_literal?
+
             check_case(case_node)
           else
             case_node.when_branches.each do |when_node|
@@ -77,7 +159,7 @@ module RuboCop
 
             check_case(case_match_node)
           else
-            case_match_node.each_in_pattern do |in_pattern_node|
+            case_match_node.in_pattern_branches.each do |in_pattern_node|
               next unless in_pattern_node.condition.literal?
 
               add_offense(in_pattern_node)
@@ -97,6 +179,21 @@ module RuboCop
 
         private
 
+        # Unwrapping the body of a loop that runs once would leave a `break`,
+        # `next` or `redo` that belongs to it outside of any loop.
+        def orphans_loop_control_keyword?(node)
+          node.body.each_node(:next, :break, :redo).any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.any_block_type? || ancestor.loop_keyword? }
+          end
+        end
+
+        def void_value_expression?(node)
+          node = node.children.last while node&.begin_type?
+
+          node&.type?(:return, :break, :next)
+        end
+
         def check_for_literal(node)
           cond = condition(node)
           if cond.literal?
@@ -130,6 +227,8 @@ module RuboCop
 
         def handle_node(node)
           if node.literal?
+            return if node.parent.and_type?
+
             add_offense(node)
           elsif %i[send and or begin].include?(node.type)
             check_node(node)
@@ -159,6 +258,48 @@ 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-next Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def correct_if_node(node, cond)
+          result = condition_evaluation?(node, cond)
+
+          # When the branch that survives the literal condition is missing,
+          # there is no meaningful correction, so no offense is registered.
+          surviving_branch = result ? node.if_branch : node.else_branch
+          return if surviving_branch.nil? && (node.elsif? || node.else?)
+
+          new_node = if node.elsif? && result
+                       "else\n  #{range_with_comments(node.if_branch).source}"
+                     elsif node.elsif? && !result
+                       "else\n  #{node.else_branch.source}"
+                     elsif node.if_branch && result
+                       node.if_branch.source
+                     elsif node.elsif_conditional?
+                       "#{node.else_branch.source.sub('elsif', 'if')}\nend"
+                     elsif node.else? || node.ternary?
+                       node.else_branch.source
+                     elsif node.value_used?
+                       'nil'
+                     else
+                       '' # Equivalent to removing the node
+                     end
+
+          add_offense(cond) do |corrector|
+            next if part_of_ignored_node?(node)
+
+            corrector.replace(node, new_node)
+
+            ignore_node(node)
+          end
+        end
       end
     end
   end

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

@@ -56,7 +56,17 @@ module RuboCop
         def traverse_node(node, &block)
           yield node if node.equals_asgn?
 
-          node.each_child_node { |child| traverse_node(child, &block) }
+          node.each_child_node do |child|
+            next if scope_body?(node, child)
+
+            traverse_node(child, &block)
+          end
+        end
+
+        # An assignment inside a block or method body within the condition belongs to
+        # that inner scope rather than the condition itself, so it is not inspected.
+        def scope_body?(node, child)
+          node.type?(:any_block, :any_def) && child == node.body
         end
 
         def all_literals?(node)

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

@@ -24,33 +24,18 @@ 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)
-
-          # %W and %I split the content into words before expansion
-          # treating each interpolation as a word component, so
-          # interpolation should not be removed if the expanded value
-          # contains a space character.
-          expanded_value = autocorrected_value(final_node)
-          expanded_value = handle_special_regexp_chars(begin_node, expanded_value)
-
-          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(expanded_value)
+          return unless (expanded_value = correctable_value(begin_node, final_node))
 
           add_offense(final_node) do |corrector|
             next if final_node.dstr_type? # nested, fixed in next iteration
+            next if follows_literal_interpolation?(begin_node)
 
-            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, replacement)
+            corrector.replace(final_node.parent, replacement(final_node, expanded_value))
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -66,7 +51,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def array_in_regexp?(node)
@@ -74,7 +59,23 @@ module RuboCop
           node.array_type? && grandparent.regexp_type?
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+        def correctable_value(begin_node, final_node)
+          value = autocorrected_value(final_node)
+          value = handle_special_regexp_chars(begin_node, value)
+          return if starts_interpolation_after_hash_sign?(begin_node, value)
+
+          value = escape_trailing_hash_sign(begin_node, value)
+
+          # %W and %I split the content into words before expansion
+          # treating each interpolation as a word component, so
+          # interpolation should not be removed if the expanded value
+          # contains a space character.
+          return if in_array_percent_literal?(begin_node) && /\s|\A\z/.match?(value)
+
+          value
+        end
+
+        # rubocop:disable-next Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -95,7 +96,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def handle_special_regexp_chars(begin_node, value)
           parent_node = begin_node.parent
@@ -118,12 +118,25 @@ module RuboCop
           end
         end
 
+        def starts_interpolation_after_hash_sign?(begin_node, value)
+          source = processed_source.buffer.source
+          range = begin_node.source_range
+          # Removing an empty value puts the `#` right before what follows the interpolation.
+          following = "#{value}#{source[range.end_pos]}"
+          return false unless following.start_with?('{', '@', '$')
+          return false unless source[range.begin_pos - 1] == '#'
+
+          unescaped_hash_sign?(source[0...range.begin_pos])
+        end
+
         def autocorrected_value_for_string(node)
-          if node.source.start_with?("'", '%q')
-            node.children.last.inspect[1..-2]
-          else
-            node.children.last
-          end
+          return node.source.delete_prefix('"').delete_suffix('"') unless node.value.valid_encoding?
+
+          escape_string_content(node.children.last)
+        end
+
+        def escape_string_content(string)
+          string.gsub(/[\\"]|#(?=[@{$])/, '\\\\\&')
         end
 
         def autocorrected_value_for_symbol(node)
@@ -134,12 +147,7 @@ module RuboCop
         end
 
         def autocorrected_value_in_hash_for_symbol(node)
-          # TODO: We need to detect symbol unacceptable names more correctly
-          if / |"|'/.match?(node.value.to_s)
-            ":\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
-          else
-            ":#{node.value}"
-          end
+          escape_string_content(node.value.inspect)
         end
 
         def autocorrected_value_for_array(node)
@@ -158,7 +166,7 @@ module RuboCop
           "{#{hash_string}}"
         end
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
         def autocorrected_value_in_hash(node)
           case node.type
           when :int
@@ -166,7 +174,7 @@ module RuboCop
           when :float
             node.children.last.to_f.to_s
           when :str
-            "\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+            escape_string_content(node.value.inspect)
           when :sym
             autocorrected_value_in_hash_for_symbol(node)
           when :array
@@ -177,7 +185,6 @@ module RuboCop
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
@@ -186,7 +193,9 @@ module RuboCop
         end
 
         def space_literal?(node)
-          node.str_type? && node.value.valid_encoding? && node.value.blank?
+          # `String#blank?` misses Unicode spaces such as U+3000 that
+          # `Layout/TrailingWhitespace` treats as trailing whitespace.
+          node.str_type? && node.value.valid_encoding? && node.value.match?(/\A[[:space:]]*\z/)
         end
 
         def ends_heredoc_line?(node)
@@ -194,7 +203,8 @@ module RuboCop
           return false unless grandparent&.dstr_type? && grandparent.heredoc?
 
           line = processed_source.lines[node.last_line - 1]
-          line.size == node.loc.last_column + 1
+
+          line.size == node.parent.source_range.last_column
         end
 
         def in_array_percent_literal?(node)
@@ -204,6 +214,34 @@ module RuboCop
           grandparent = parent.parent
           grandparent&.array_type? && grandparent.percent_literal?
         end
+
+        def escape_trailing_hash_sign(begin_node, value)
+          following = processed_source.buffer.source[begin_node.source_range.end_pos]
+          return value unless %w[{ @ $].include?(following) && unescaped_hash_sign?(value)
+
+          "#{value.delete_suffix('#')}\\#"
+        end
+
+        def unescaped_hash_sign?(text)
+          text.end_with?('#') && text.delete_suffix('#')[/\\*\z/].length.even?
+        end
+
+        # Each interpolation is checked against the original source, so correcting it in the
+        # same pass as a preceding one that leaves a `#` (or nothing) could join that `#` and
+        # a `{` from this one. It's left for the next iteration instead.
+        def follows_literal_interpolation?(begin_node)
+          previous = begin_node.left_sibling
+          return false unless previous&.begin_type? && offending?(previous.children.last)
+
+          value = correctable_value(previous, previous.children.last)
+          value && (value.empty? || value.end_with?('#'))
+        end
+
+        def replacement(node, expanded_value)
+          return expanded_value unless node.str_type? && !node.value.valid_encoding?
+
+          node.source.delete_prefix('"').delete_suffix('"')
+        end
       end
     end
   end

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

@@ -42,6 +42,8 @@ module RuboCop
       #     break if some_condition
       #   end
       class Loop < Base
+        include Alignment
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `Kernel#loop` with `break` rather than `begin/end/until`(or `while`).'
@@ -62,7 +64,8 @@ module RuboCop
           add_offense(node.loc.keyword) do |corrector|
             corrector.replace(body.loc.begin, 'loop do')
             corrector.remove(keyword_and_condition_range(node))
-            corrector.insert_before(body.loc.end, build_break_line(node))
+
+            insert_break_line(corrector, node, body)
           end
         end
 
@@ -70,9 +73,28 @@ module RuboCop
           node.body.loc.end.end.join(node.source_range.end)
         end
 
+        def insert_break_line(corrector, node, body)
+          if body.single_line?
+            corrector.replace(space_before_end(body), build_break_line(node))
+          else
+            corrector.insert_before(body.loc.end, build_break_line(node))
+          end
+        end
+
+        def space_before_end(body)
+          range = range_with_surrounding_space(range: body.loc.end, side: :left, newlines: false)
+
+          range.with(end_pos: body.loc.end.begin_pos)
+        end
+
         def build_break_line(node)
           conditional_keyword = node.while_post_type? ? 'unless' : 'if'
-          "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          break_line = "break #{conditional_keyword} #{node.condition.source}\n#{indent(node)}"
+          return break_line unless node.body.single_line?
+
+          # A single-line `begin ... end` keeps its body and `end` on one line,
+          # so the `break` has to start a line of its own.
+          "\n#{indent(node, offset: configured_indentation_width)}#{break_line}"
         end
       end
     end