rubocop 1.66.0 → 1.67.0

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

@@ -13,8 +13,10 @@ module RuboCop
       # return value of `Enumerable#map` is an `Array`. They are not autocorrected
       # when a return value could be used because these types differ.
       #
-      # NOTE: It only detects when the mapping destination is a local variable
-      # initialized as an empty array and referred to only by the pushing operation.
+      # NOTE: It only detects when the mapping destination is either:
+      # * a local variable initialized as an empty array and referred to only by the
+      # pushing operation;
+      # * or, if it is the single block argument to a `[].tap` block.
       # This is because, if not, it's challenging to statically guarantee that the
       # mapping destination variable remains an empty array:
       #
@@ -42,6 +44,14 @@ module RuboCop
       #   # good
       #   dest = src.map { |e| e * 2 }
       #
+      #   # bad
+      #   [].tap do |dest|
+      #     src.each { |e| dest << e * 2 }
+      #   end
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
       #   # good - contains another operation
       #   dest = []
       #   src.each { |e| dest << e * 2; puts e }
@@ -56,7 +66,7 @@ module RuboCop
         # @!method each_block_with_push?(node)
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
-            ^({begin kwbegin} ...)
+            ^({begin kwbegin block} ...)
             ({block numblock} (send !{nil? self} :each) _
               (send (lvar _) {:<< :push :append} {send lvar begin}))
           ]
@@ -74,6 +84,16 @@ module RuboCop
           )
         PATTERN
 
+        # @!method empty_array_tap(node)
+        def_node_matcher :empty_array_tap, <<~PATTERN
+          ^^$(
+            block
+              (send (array) :tap)
+              (args (arg _))
+              ...
+          )
+        PATTERN
+
         # @!method lvar_ref?(node, name)
         def_node_matcher :lvar_ref?, '(lvar %1)'
 
@@ -89,9 +109,14 @@ module RuboCop
           return unless each_block_with_push?(node)
 
           dest_var = find_dest_var(node)
-          return unless (asgn = find_closest_assignment(node, dest_var))
-          return unless empty_array_asgn?(asgn)
-          return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+
+          if offending_empty_array_tap?(node, dest_var)
+            asgn = dest_var.declaration_node
+          else
+            return unless (asgn = find_closest_assignment(node, dest_var))
+            return unless empty_array_asgn?(asgn)
+            return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+          end
 
           register_offense(node, dest_var, asgn)
         end
@@ -108,6 +133,15 @@ module RuboCop
           candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
         end
 
+        def offending_empty_array_tap?(node, dest_var)
+          return false unless (tap_block_node = empty_array_tap(dest_var.declaration_node))
+
+          # A `tap` block only offends if the array push is the only thing in it;
+          # otherwise we cannot guarantee that the block variable is still an empty
+          # array when pushed to.
+          tap_block_node.body == node
+        end
+
         def find_closest_assignment(block, dest_var)
           dest_var.assignments.reverse_each.lazy.map(&:node).find do |node|
             node.source_range.end_pos < block.source_range.begin_pos
@@ -127,7 +161,13 @@ module RuboCop
             next if return_value_used?(block)
 
             corrector.replace(block.send_node.selector, new_method_name)
-            remove_assignment(corrector, asgn)
+
+            if (tap_block_node = empty_array_tap(dest_var.declaration_node))
+              remove_tap(corrector, block, tap_block_node)
+            else
+              remove_assignment(corrector, asgn)
+            end
+
             correct_push_node(corrector, block.body)
             correct_return_value_handling(corrector, block, dest_var)
           end
@@ -147,10 +187,8 @@ module RuboCop
             false
           when :begin, :kwbegin
             !node.right_sibling && return_value_used?(parent)
-          when :block, :numblock
-            !parent.void_context?
           else
-            true
+            !parent.respond_to?(:void_context?) || !parent.void_context?
           end
         end
 
@@ -161,6 +199,12 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def remove_tap(corrector, node, block_node)
+          range = range_between(block_node.source_range.begin_pos, node.source_range.begin_pos)
+          corrector.remove(range)
+          corrector.remove(range_with_surrounding_space(block_node.loc.end, side: :left))
+        end
+
         def correct_push_node(corrector, push_node)
           range = push_node.source_range
           arg_range = push_node.first_argument.source_range

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -7,6 +7,8 @@ module RuboCop
         # Style omit_parentheses
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
@@ -30,10 +32,13 @@ module RuboCop
           end
 
           def autocorrect(corrector, node)
+            range = args_begin(node)
             if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
             else
-              corrector.replace(args_begin(node), ' ')
+              corrector.replace(range, ' ')
             end
             corrector.remove(node.loc.end)
           end
@@ -47,11 +52,11 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          def require_parentheses_for_hash_value_omission?(node)
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            node.parent&.conditional? || !last_expression?(node)
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
@@ -127,7 +132,7 @@ module RuboCop
           end
 
           def call_in_single_line_inheritance?(node)
-            node.parent&.class_type? && node.parent&.single_line?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -147,7 +152,7 @@ module RuboCop
           end
 
           def call_in_argument_with_block?(node)
-            parent = node.parent&.block_type? && node.parent&.parent
+            parent = node.parent&.block_type? && node.parent.parent
             return false unless parent
 
             parent.call_type? || parent.super_type? || parent.yield_type?
@@ -211,7 +216,7 @@ module RuboCop
 
           def unary_literal?(node)
             (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent&.unary_operation?)
+              (node.parent&.send_type? && node.parent.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -43,7 +43,7 @@ module RuboCop
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def modifier?(node)
-          node&.basic_conditional? && node&.modifier_form?
+          node&.basic_conditional? && node.modifier_form?
         end
 
         def autocorrect(corrector, node)

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

@@ -39,7 +39,7 @@ module RuboCop
             next if allowed_omission?(nested)
 
             message = format(MSG, source: nested.source)
-            add_offense(nested.source_range, message: message) do |corrector|
+            add_offense(nested, message: message) do |corrector|
               autocorrect(corrector, nested)
             end
           end

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

@@ -46,7 +46,11 @@ module RuboCop
 
           message = message(node)
           add_offense(node, message: message) do |corrector|
+            next if part_of_ignored_node?(node)
+
             autocorrect(corrector, node)
+
+            ignore_node(node)
           end
         end
 

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

@@ -22,6 +22,9 @@ module RuboCop
 
         MSG = 'Redundant dot detected.'
         RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+        INVALID_SYNTAX_ARG_TYPES = %i[
+          splat kwsplat forwarded_args forwarded_restarg forwarded_kwrestarg block_pass
+        ].freeze
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def on_send(node)
@@ -29,14 +32,16 @@ module RuboCop
           return if node.receiver.const_type? || !node.arguments.one?
 
           _lhs, _op, rhs = *node
-          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
+          if !rhs || method_call_with_parenthesized_arg?(rhs) || invalid_syntax_argument?(rhs)
+            return
+          end
 
           add_offense(dot) do |corrector|
             wrap_in_parentheses_if_chained(corrector, node)
             corrector.replace(dot, ' ')
 
             selector = node.loc.selector
-            corrector.insert_after(selector, ' ') if selector.end_pos == rhs.source_range.begin_pos
+            corrector.insert_after(selector, ' ') if insert_space_after?(node)
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
@@ -50,11 +55,10 @@ module RuboCop
           argument.children.first && argument.parent.parenthesized?
         end
 
-        def anonymous_forwarding?(argument)
-          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
-          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
+        def invalid_syntax_argument?(argument)
+          type = argument.hash_type? ? argument.children.first&.type : argument.type
 
-          argument.block_pass_type? && argument.source == '&'
+          INVALID_SYNTAX_ARG_TYPES.include?(type)
         end
 
         def wrap_in_parentheses_if_chained(corrector, node)
@@ -67,6 +71,21 @@ module RuboCop
           corrector.insert_after(operator, ' ')
           corrector.wrap(node, '(', ')')
         end
+
+        def insert_space_after?(node)
+          _lhs, op, rhs = *node
+          selector = node.loc.selector
+
+          return true if selector.end_pos == rhs.source_range.begin_pos
+          return false if node.parent&.call_type? # if chained, a space is already added
+
+          # For `/` operations, if the RHS starts with a `(` without space,
+          # add one to avoid a syntax error.
+          range = selector.end.join(rhs.source_range.begin)
+          return true if op == :/ && range.source == '('
+
+          false
+        end
       end
     end
   end

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

@@ -68,6 +68,10 @@ module RuboCop
 
         MSG = 'Redundant `begin` block detected.'
 
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
         # @!method offensive_kwbegins(node)
         def_node_search :offensive_kwbegins, <<~PATTERN
           [(kwbegin ...) !#allowable_kwbegin?]

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

@@ -94,7 +94,7 @@ module RuboCop
         end
 
         def use_hash_key_assignment?(else_branch)
-          else_branch&.send_type? && else_branch&.method?(:[]=)
+          else_branch&.send_type? && else_branch.method?(:[]=)
         end
 
         def use_hash_key_access?(node)

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

@@ -16,7 +16,7 @@ module RuboCop
       #   "#{foo} bar".dup
       #
       #   # good
-      #  "#{foo} bar"
+      #   "#{foo} bar"
       #
       class RedundantInterpolationUnfreeze < Base
         include FrozenStringLiteral

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

@@ -122,7 +122,7 @@ module RuboCop
         end
 
         def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.line))
+          return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
           source = node.parent ? node.parent.source : node.source
@@ -160,9 +160,9 @@ module RuboCop
         end
         # rubocop:enable Metrics/AbcSize
 
-        def find_node_for_line(line)
+        def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|
-            return node if same_line?(node, line)
+            return node if node.respond_to?(:expression) && node.expression&.last_line == last_line
           end
         end
 

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

@@ -160,7 +160,7 @@ module RuboCop
             return if node.semantic_operator? && begin_node.parent
             return if node.multiline? && allow_in_multiline_conditions?
             return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
-            return if begin_node.parent&.if_type? && begin_node.parent&.ternary?
+            return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?

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

@@ -103,7 +103,7 @@ module RuboCop
             next unless sibling.is_a?(AST::Node)
 
             sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling&.method?(node.method_name)
+            break unless sibling&.send_type? && sibling.method?(node.method_name)
             break unless sibling.arguments? && !sibling.receiver
             break unless in_same_section?(sibling, node)
             break unless node.first_argument.str_type? && sibling.first_argument.str_type?

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

@@ -75,7 +75,7 @@ module RuboCop
 
           corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
           corrector.insert_before(operation, "begin\n#{node_indentation}")
-          corrector.insert_after(operation, <<~RESCUE_CLAUSE.chop)
+          corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
 
             #{node_offset}rescue
             #{node_indentation}#{rescue_args.source}
@@ -92,6 +92,18 @@ module RuboCop
           end
           [node_indentation, node_offset]
         end
+
+        def heredoc_end(node)
+          return unless node.call_type?
+
+          heredoc = node.arguments.reverse.find do |argument|
+            argument.respond_to?(:heredoc?) && argument.heredoc?
+          end
+
+          return unless heredoc
+
+          heredoc.loc.heredoc_end
+        end
       end
     end
   end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks if `return` or `return nil` is used in predicate method definitions.
+      # Checks for predicate method definitions that return `nil`.
+      # A predicate method should only return a boolean value.
       #
       # @safety
       #   Autocorrection is marked as unsafe because the change of the return value
@@ -31,6 +32,24 @@ module RuboCop
       #     do_something?
       #   end
       #
+      #   # bad
+      #   def foo?
+      #     if condition
+      #       nil
+      #     else
+      #       true
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     if condition
+      #       false
+      #     else
+      #       true
+      #     end
+      #   end
+      #
       # @example AllowedMethods: ['foo?']
       #   # good
       #   def foo?
@@ -64,24 +83,25 @@ module RuboCop
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return unless (body = node.body)
 
-          body.each_descendant(:return) do |return_node|
-            register_offense(return_node, 'return false') if return_nil?(return_node)
-          end
-
-          return unless (nil_node = nil_node_at_the_end_of_method_body(body))
+          body.each_descendant(:return) { |return_node| handle_return(return_node) }
 
-          register_offense(nil_node, 'false')
+          handle_implicit_return_values(body)
         end
         alias on_defs on_def
 
         private
 
-        def nil_node_at_the_end_of_method_body(body)
-          return body if body.nil_type?
-          return unless body.begin_type?
-          return unless (last_child = body.children.last)
+        def last_node_of_type(node, type)
+          return unless node
+          return node if node_type?(node, type)
+          return unless node.begin_type?
+          return unless (last_child = node.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && node_type?(last_child, type)
+        end
 
-          last_child if last_child.is_a?(AST::Node) && last_child.nil_type?
+        def node_type?(node, type)
+          node.type == type.to_sym
         end
 
         def register_offense(offense_node, replacement)
@@ -89,6 +109,28 @@ module RuboCop
             corrector.replace(offense_node, replacement)
           end
         end
+
+        def handle_implicit_return_values(node)
+          handle_if(last_node_of_type(node, :if))
+          handle_nil(last_node_of_type(node, :nil))
+        end
+
+        def handle_return(return_node)
+          register_offense(return_node, 'return false') if return_nil?(return_node)
+        end
+
+        def handle_nil(nil_node)
+          return unless nil_node
+
+          register_offense(nil_node, 'false')
+        end
+
+        def handle_if(if_node)
+          return unless if_node
+
+          handle_implicit_return_values(if_node.if_branch)
+          handle_implicit_return_values(if_node.else_branch)
+        end
       end
     end
   end