rubocop 1.90.0 → 1.92.0

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

@@ -53,6 +53,12 @@ module RuboCop
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
+        # A hash literal as the first argument needs the parentheses of the call,
+        # which `Style/MethodCallWithArgsParentheses` removes in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
@@ -95,12 +101,30 @@ module RuboCop
         def register_offense_for_hash(node, hash_argument)
           add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
             corrector.replace(node, "{#{hash_argument.source}}")
-
-            parent = node.parent
-            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 
+        # Without parentheses, a hash literal at the start of the first argument would be
+        # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`.
+        def add_parentheses_to_parent_call(node, corrector)
+          node = node.parent while starts_parent?(node)
+          parent = node.parent
+          return unless parent&.type?(:call, :super, :yield)
+          return if parent.parenthesized? || operator_syntax?(parent)
+
+          add_parentheses(parent, corrector)
+        end
+
+        def starts_parent?(node)
+          node.parent && node.parent.source_range.begin_pos == node.source_range.begin_pos
+        end
+
+        # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is.
+        def operator_syntax?(call)
+          call.setter_method? || (call.operator_method? && !call.loc?(:dot))
+        end
+
         def register_offense_for_zip_method(node, zip_method)
           add_offense(node, message: MSG_TO_H) do |corrector|
             if zip_method.parenthesized?
@@ -135,11 +159,7 @@ module RuboCop
         def correct_multi_argument(node)
           add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
             corrector.replace(node, args_to_hash(node.arguments))
-
-            parent = node.parent
-            if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
-              add_parentheses(parent, corrector)
-            end
+            add_parentheses_to_parent_call(node, corrector)
           end
         end
 

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

@@ -34,6 +34,9 @@ module RuboCop
       #   # good - fetch with block is allowed
       #   hash.fetch(key) { default }
       #
+      #   # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled
+      #   ENV.fetch(key)
+      #
       # @example EnforcedStyle: fetch
       #   # bad
       #   hash[key]
@@ -55,14 +58,20 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[[] fetch].freeze
 
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, '(const {nil? cbase} :ENV)'
+
         def on_send(node)
           return if (receiver = node.receiver) && allowed_receiver?(receiver)
+          return if part_of_ignored_node?(node)
 
           if offense_for_brackets?(node)
+            ignore_node(node.first_argument)
             add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
               correct_fetch_to_brackets(corrector, node)
             end
           elsif offense_for_fetch?(node)
+            ignore_node(node.first_argument)
             add_offense(node, message: FETCH_MSG) do |corrector|
               correct_brackets_to_fetch(corrector, node)
             end
@@ -73,28 +82,45 @@ module RuboCop
         private
 
         def offense_for_brackets?(node)
-          style == :brackets && node.receiver && node.method?(:fetch) && node.arguments.one? &&
-            !node.block_literal? && !node.csend_type?
+          return false if style != :brackets || !node.receiver
+          return false if !node.method?(:fetch) || !node.arguments.one?
+          return false if node.block_literal? || node.csend_type?
+
+          !exempt_from_brackets?(node)
+        end
+
+        def exempt_from_brackets?(node)
+          comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
+        end
+
+        def comment_before_dot?(node)
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def env_fetch_preferred?(receiver)
+          env_const?(receiver) && processed_source.registry.enabled?(Style::FetchEnvVar, config)
         end
 
         def offense_for_fetch?(node)
-          style == :fetch && node.method?(:[]) && node.arguments.one?
+          style == :fetch && node.method?(:[]) && node.arguments.one? &&
+            !compound_assignment_target?(node)
+        end
+
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
         end
 
         def correct_fetch_to_brackets(corrector, node)
           key = node.first_argument.source
 
-          corrector.replace(node.loc.dot.join(node.source_range.end), "[#{key}]")
+          corrector.replace(node.receiver.source_range.end.join(node.source_range.end), "[#{key}]")
         end
 
         def correct_brackets_to_fetch(corrector, node)
           key = node.first_argument.source
+          replacement = node.loc.dot ? "fetch(#{key})" : ".fetch(#{key})"
 
-          if node.csend_type?
-            corrector.replace(node.loc.dot.join(node.source_range.end), "&.fetch(#{key})")
-          else
-            corrector.replace(node.loc.selector.join(node.source_range.end), ".fetch(#{key})")
-          end
+          corrector.replace(node.loc.selector.join(node.source_range.end), replacement)
         end
       end
     end

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

@@ -142,6 +142,13 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
         NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
+        # Omitting the last hash value of a call without parentheses adds the parentheses,
+        # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses`
+        # would add again in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::SuperWithArgsParentheses]
+        end
+
         def on_hash(node)
           pairs = node.pairs
 
@@ -241,6 +248,8 @@ module RuboCop
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
+              next if pair.value_omission? && keyword_value?(pair)
+
               location = pair.source_range.begin.join(pair.loc.operator)
               add_offense(location, message: msg) do |corrector|
                 autocorrect(corrector, pair)
@@ -283,12 +292,16 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          op = pair_node.loc.operator
-
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
           key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(op))
+          corrector.remove(operator_range(pair_node))
+        end
+
+        def operator_range(pair_node)
+          op = pair_node.loc.operator
+
+          range_with_surrounding_space(op, newlines: !pair_node.value_omission?)
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -188,7 +188,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -198,8 +198,7 @@ module RuboCop
             add_offense(expression) do |corrector|
               next if node.if_type? && (node.ternary? || node.then?)
 
-              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
-              corrector.remove(range)
+              corrector.remove(removal_range(expression))
               next if inserted_expression
 
               if node.parent&.assignment?
@@ -213,6 +212,26 @@ module RuboCop
           end
         end
 
+        def removal_range(expression)
+          range = expression.source_range
+          whole_lines = range_by_whole_lines(range, include_final_newline: true)
+          return whole_lines if whole_lines.source.strip == expression.source
+
+          range_with_separator(range)
+        end
+
+        def range_with_separator(range)
+          source = range.source_buffer.source
+
+          if (following = source[range.end_pos..][/\A[ \t]*;[ \t]*/])
+            range.adjust(end_pos: following.length)
+          elsif (preceding = source[0...range.begin_pos][/[ \t]*;[ \t]*\z/])
+            range.adjust(begin_pos: -preceding.length)
+          else
+            range_with_surrounding_space(range, side: :right, newlines: false)
+          end
+        end
+
         def correct_assignment(corrector, node, expression, insert_position)
           indentation = indentation_of(node.parent)
 

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

@@ -75,7 +75,7 @@ module RuboCop
           return if comments_between_else_and_if?(node, else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
-            next if part_of_ignored_node?(node)
+            next if part_of_ignored_node?(node) || shares_lines_with_other_code?(else_branch)
 
             autocorrect(corrector, else_branch)
             ignore_node(node)
@@ -84,6 +84,26 @@ module RuboCop
 
         private
 
+        # The `elsif` correction moves and removes whole lines, so it can't be applied when
+        # the nested `if` condition, its `if` branch or its `end` shares a line with other code.
+        # A modifier `if` on the `else` line would leave its body on the `elsif` line.
+        def shares_lines_with_other_code?(node)
+          return false if node.then?
+          return !begins_its_line?(node.source_range) if node.modifier_form?
+
+          moved_ranges(node).any? { |range| !begins_its_line?(range) || !ends_its_line?(range) }
+        end
+
+        def moved_ranges(node)
+          ranges = [if_condition_range(node, node.condition), find_end_range(node)]
+          ranges << range_with_comments(node.if_branch) if node.if_branch
+          ranges
+        end
+
+        def ends_its_line?(range)
+          processed_source.lines[range.last_line - 1][range.last_column..].match?(/\A\s*(#|\z)/)
+        end
+
         def autocorrect(corrector, node)
           if node.then?
             # If the nested `if` is a then node, correct it first,

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

@@ -159,7 +159,7 @@ module RuboCop
           corrector.replace(node, replacement)
         end
 
-        def replacement_for_modifier_form(corrector, node) # rubocop:disable Metrics/AbcSize
+        def replacement_for_modifier_form(corrector, node)
           comment = comment_on_node_line(node)
           if comment && too_long_due_to_comment_after_modifier?(node, comment)
             remove_comment(corrector, node, comment)
@@ -167,12 +167,11 @@ module RuboCop
             return to_modifier_form_with_move_comment(node, indent(node), comment)
           end
 
-          last_argument = node.if_branch.last_argument if node.if_branch.send_type?
-          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
-            heredoc = extract_heredoc_from(last_argument)
-            remove_heredoc(corrector, heredoc)
+          heredoc_ranges = heredoc_ranges_in(node.if_branch)
+          unless heredoc_ranges.empty?
+            remove_heredoc(corrector, heredoc_ranges)
 
-            return to_normal_form_with_heredoc(node, indent(node), heredoc)
+            return to_normal_form_with_heredoc(node, indent(node), heredoc_ranges)
           end
 
           to_normal_form(node, indent(node))
@@ -275,14 +274,19 @@ module RuboCop
           RUBY
         end
 
-        def to_normal_form_with_heredoc(node, indentation, heredoc)
-          heredoc_body, heredoc_end = heredoc
+        def remove_heredoc(corrector, heredoc_ranges)
+          heredoc_ranges.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
+
+        def to_normal_form_with_heredoc(node, indentation, heredoc_ranges)
+          heredoc_lines = heredoc_ranges.map(&:source)
 
           <<~RUBY.chomp
             #{node.keyword} #{node.condition.source}
             #{indentation}  #{node.body.source}
-            #{indentation}  #{heredoc_body.source.chomp}
-            #{indentation}  #{heredoc_end.source.chomp}
+            #{heredoc_lines.join("\n")}
             #{indentation}end
           RUBY
         end
@@ -294,17 +298,12 @@ module RuboCop
           RUBY
         end
 
-        def extract_heredoc_from(last_argument)
-          heredoc_body = last_argument.loc.heredoc_body
-          heredoc_end = last_argument.loc.heredoc_end
-
-          [heredoc_body, heredoc_end]
-        end
-
-        def remove_heredoc(corrector, heredoc)
-          heredoc.each do |range|
-            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        def heredoc_ranges_in(body)
+          ranges = body.each_node(:any_str).select(&:heredoc?).map do |heredoc|
+            range_by_whole_lines(heredoc.loc.heredoc_body.join(heredoc.loc.heredoc_end))
           end
+          # A heredoc opened in another heredoc's interpolation is moved along with it.
+          ranges.reject { |range| ranges.any? { |other| other.contains?(range) } }
         end
 
         def comment_on_node_line(node)

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

@@ -28,6 +28,10 @@ module RuboCop
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         # rubocop:disable-next Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?

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

@@ -21,6 +21,10 @@ module RuboCop
         MSG_NEWLINE = 'Do not use `%<keyword>s %<expr>s;` - use a newline instead.'
         MSG_TERNARY = 'Do not use `%<keyword>s %<expr>s;` - use a ternary operator instead.'
 
+        LOWER_PRECEDENCE_THAN_TERNARY_TYPES = %i[
+          and or if rescue any_match_pattern while until while_post until_post
+        ].freeze
+
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
           return if part_of_ignored_node?(node)
@@ -77,12 +81,14 @@ module RuboCop
         def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
-          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
+          then_code = node.if_branch ? ternary_operand(node.if_branch) : 'nil'
+          else_code = node.else_branch ? ternary_operand(node.else_branch) : 'nil'
 
           then_code, else_code = else_code, then_code if node.unless?
 
-          "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+          ternary = "#{ternary_condition(node)} ? #{then_code} : #{else_code}"
+
+          operand_of_parent?(node) ? "(#{ternary})" : ternary
         end
 
         def correct_elsif(node)
@@ -108,7 +114,34 @@ module RuboCop
         # `(a = b) ? c : d`), changing what gets assigned.
         def ternary_condition(node)
           condition = node.condition
-          condition.assignment? ? "(#{condition.source})" : condition.source
+          condition.assignment? ? "(#{condition.source})" : ternary_operand(condition)
+        end
+
+        def ternary_operand(expr)
+          lower_precedence_than_ternary?(expr) ? "(#{expr.source})" : build_expression(expr)
+        end
+
+        # Expressions that bind looser than `?:` (or cannot appear unparenthesized
+        # inside it) would otherwise absorb or break the ternary.
+        def lower_precedence_than_ternary?(node)
+          return true if node.type?(*LOWER_PRECEDENCE_THAN_TERNARY_TYPES)
+          return true if node.send_type? && (node.prefix_not? || prefix_bang_on_command?(node))
+
+          node.type?(:yield, :super, :defined?) && node.arguments.any? && !node.parenthesized?
+        end
+
+        def operand_of_parent?(node)
+          return false unless (parent = node.parent)
+          return true if parent.operator_keyword?
+
+          parent.call_type? && call_operand?(parent, node)
+        end
+
+        def call_operand?(call, node)
+          return false if call.prefix_not?
+          return true if call.receiver.equal?(node)
+
+          call.operator_method? && !call.method?(:[]) && !call.method?(:[]=)
         end
 
         def build_else_branch(second_condition)
@@ -131,6 +164,16 @@ module RuboCop
           result
         end
 
+        # `!foo a` leaves the arguments of `foo` unparenthesized at the end of the operand,
+        # where they would absorb the rest of the ternary.
+        def prefix_bang_on_command?(node)
+          return false unless node.prefix_bang?
+
+          receiver = node.receiver
+
+          require_argument_parentheses?(receiver) || lower_precedence_than_ternary?(receiver)
+        end
+
         def require_argument_parentheses?(node)
           return false if !node.call_type? || node.arithmetic_operation?
 

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

@@ -114,9 +114,31 @@ module RuboCop
           method_call, _lhs, method, _rhs = inverse_candidate?(node)
           return unless method_call && method
 
-          corrector.remove(not_to_receiver(node, method_call))
+          remove_negation(corrector, node, method, method_call)
           corrector.replace(method_call.loc.selector, inverse_methods[method].to_s)
-          remove_end_parenthesis(corrector, node, method, method_call)
+        end
+
+        def remove_negation(corrector, node, method, method_call)
+          if !keep_parentheses?(node, method_call)
+            corrector.remove(not_to_receiver(node, method_call))
+            remove_end_parenthesis(corrector, node, method, method_call)
+          elsif node.parenthesized?
+            corrector.remove(node.loc.selector)
+          else
+            corrector.remove(node.loc.selector.join(node.receiver.source_range.begin))
+          end
+        end
+
+        def keep_parentheses?(node, method_call)
+          return false unless node.receiver.begin_type? || node.parenthesized?
+          return false unless method_call.operator_method?
+          return false unless (parent = node.parent)&.call_type?
+
+          binary_operator?(parent) || parent.receiver.equal?(node)
+        end
+
+        def binary_operator?(node)
+          node.operator_method? && !node.loc.dot && !node.method?(:[]) && !node.method?(:[]=)
         end
 
         def correct_inverse_block(corrector, node)

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

@@ -61,6 +61,12 @@ module RuboCop
 
         minimum_target_ruby_version 3.4
 
+        # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass,
+        # which would leave an empty parameter list that forbids `it`.
+        def self.autocorrect_incompatible_with
+          [Style::Lambda, Style::StabbyLambdaParentheses]
+        end
+
         def on_block(node)
           return unless style == :always
           return unless node.arguments.one?
@@ -68,9 +74,10 @@ module RuboCop
           # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
           return unless node.first_argument.arg_type?
 
-          variables = find_block_variables(node, node.first_argument.source)
+          block_argument_name = node.first_argument.source
+          return if used_within_inner_block?(node.body, block_argument_name)
 
-          variables.each do |variable|
+          find_block_variables(node, block_argument_name).each do |variable|
             add_offense(variable, message: MSG_USE_IT_PARAMETER) do |corrector|
               corrector.remove(node.arguments)
               corrector.replace(variable, 'it')
@@ -111,7 +118,29 @@ module RuboCop
         def find_block_variables(node, block_argument_name)
           return [] unless node.body
 
-          node.body.each_descendant(:lvar).select do |descendant|
+          ranges = inner_block_ranges(node.body)
+
+          block_variables(node.body, block_argument_name).reject do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def inner_block_ranges(body)
+          body.each_node(:any_block).map { |block| block.loc.begin.join(block.loc.end) }
+        end
+
+        def used_within_inner_block?(body, block_argument_name)
+          return false unless body
+
+          ranges = inner_block_ranges(body)
+
+          block_variables(body, block_argument_name).any? do |variable|
+            ranges.any? { |range| range.contains?(variable.source_range) }
+          end
+        end
+
+        def block_variables(body, block_argument_name)
+          body.each_descendant(:lvar).select do |descendant|
             descendant.source == block_argument_name
           end
         end

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

@@ -75,7 +75,9 @@ module RuboCop
 
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
-            with_space = range_with_surrounding_space(kwarg.source_range)
+            range = range_with_surrounding_space(kwarg.source_range, side: :left, whitespace: true)
+            with_space = range_with_surrounding_space(range, side: :right)
+
             corrector.remove(range_with_surrounding_comma(with_space, :left))
           end
         end

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

@@ -48,6 +48,8 @@ module RuboCop
       #       end
       class Lambda < Base
         include ConfigurableEnforcedStyle
+        include PatternMatchingHelp
+        include RescueNode
         extend AutoCorrector
 
         LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
@@ -71,6 +73,7 @@ module RuboCop
           selector = node.send_node.source
 
           return unless offending_selector?(node, selector)
+          return if uncorrectable_lambda_literal?(node)
 
           add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
@@ -91,6 +94,21 @@ module RuboCop
           selector == OFFENDING_SELECTORS[:style][style][lines]
         end
 
+        def uncorrectable_lambda_literal?(node)
+          return false unless node.send_node.lambda_literal?
+          return true if in_pattern?(node)
+          return false unless rescue_or_ensure_clause?(node.body)
+
+          LambdaLiteralToMethodCorrector.new(node).replace_delimiters?
+        end
+
+        def rescue_or_ensure_clause?(body)
+          return false unless body
+          return true if body.ensure_type?
+
+          body.rescue_type? && !rescue_modifier?(body.resbody_branches.first)
+        end
+
         def message(node, selector)
           message = selector == '->' ? METHOD_MESSAGE : LITERAL_MESSAGE
 

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

@@ -28,8 +28,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
           # Rewriting the call rebuilds it as a single expression, which would drop
-          # any comments inside the argument list, so leave it to be fixed manually.
-          return if comments_in_node?(node)
+          # any comments or heredoc bodies inside the argument list, so leave it to be
+          # fixed manually.
+          return if comments_in_node?(node) || heredoc_argument?(node)
 
           if offense?(node)
             prefer = prefer(node)
@@ -59,6 +60,10 @@ module RuboCop
           end
         end
 
+        def heredoc_argument?(node)
+          node.arguments.any? { |argument| argument.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def offense?(node)
           (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end

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

@@ -187,7 +187,7 @@ module RuboCop
             issues[:directives] << directive if directive_offends?(directive)
           end
 
-          comment.values.each do |value| # rubocop:disable Style/HashEachMethods
+          comment.values.each do |value| # rubocop:disable Style/HashEachMethods -- the receiver is a magic comment, not a Hash
             issues[:values] << value if wrong_capitalization?(value.source, value_capitalization)
           end
 

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

@@ -112,8 +112,7 @@ module RuboCop
 
         def on_block(node)
           return unless each_block_with_push?(node)
-
-          dest_var = find_dest_var(node)
+          return unless (dest_var = find_dest_var(node))
 
           if offending_empty_array_tap?(node, dest_var)
             asgn = dest_var.declaration_node