rubocop 1.24.1 → 1.64.1

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -29,7 +29,7 @@ module RuboCop
 
       # Returns the range bounds for just the annotation
       def bounds
-        start = comment.loc.expression.begin_pos + margin.length
+        start = comment.source_range.begin_pos + margin.length
         length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
         [start, start + length]
       end
@@ -41,18 +41,25 @@ module RuboCop
       def split_comment(comment)
         # Sort keywords by reverse length so that if a keyword is in a phrase
         # but also on its own, both will match properly.
-        keywords_regex = Regexp.new(
-          Regexp.union(keywords.sort_by { |w| -w.length }).source,
-          Regexp::IGNORECASE
-        )
-        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
-
         match = comment.text.match(regex)
         return false unless match
 
         match.captures
       end
 
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      private_constant :KEYWORDS_REGEX_CACHE
+
+      def regex
+        KEYWORDS_REGEX_CACHE[keywords] ||= begin
+          keywords_regex = Regexp.new(
+            Regexp.union(keywords.sort_by { |w| -w.length }).source,
+            Regexp::IGNORECASE
+          )
+          /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+        end
+      end
+
       def keyword_appearance?
         keyword && (colon || space)
       end

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -46,6 +46,8 @@ module RuboCop
         if node.send_type?
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
+        elsif node.def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.array_type? || node.hash_type?
           return extract_breakable_node_from_elements(node, node.children, max)
         end
@@ -216,7 +218,9 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        node.first_line != node.last_line
+        return node.first_line != node.last_argument.last_line if node.def_type?
+
+        !node.single_line?
       end
     end
   end

data/lib/rubocop/cop/mixin/code_length.rb

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.loc.expression
+        location = location(node)
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end
@@ -54,6 +54,17 @@ module RuboCop
           foldable_types: count_as_one
         )
       end
+
+      def location(node)
+        return node.loc.name if node.casgn_type?
+
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -4,8 +4,6 @@ module RuboCop
   module Cop
     # Help methods for working with nodes containing comments.
     module CommentsHelp
-      include VisibilityHelp
-
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
@@ -13,10 +11,33 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
+      def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
+        start_line = node.source_range.line
+        end_line = find_end_line(node)
+
+        processed_source.each_comment_in_lines(start_line...end_line)
+      end
+
+      def comments_contain_disables?(node, cop_name)
+        disabled_ranges = processed_source.disabled_line_ranges[cop_name]
+
+        return false unless disabled_ranges
+
+        node_range = node.source_range.line...find_end_line(node)
+
+        disabled_ranges.any? do |disable_range|
+          disable_range.cover?(node_range) || node_range.cover?(disable_range)
+        end
+      end
+
       private
 
       def end_position_for(node)
-        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        end_line = buffer.line_for_position(node.source_range.end_pos)
         buffer.line_range(end_line).end_pos
       end
 
@@ -37,6 +58,33 @@ module RuboCop
       def buffer
         processed_source.buffer
       end
+
+      # Returns the end line of a node, which might be a comment and not part of the AST
+      # End line is considered either the line at which another node starts, or
+      # the line at which the parent node ends.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def find_end_line(node)
+        if node.if_type?
+          if node.else?
+            node.loc.else.line
+          elsif node.ternary?
+            node.else_branch.loc.line
+          elsif node.elsif?
+            node.each_ancestor(:if).find(&:if?).loc.end.line
+          end
+        elsif node.block_type? || node.numblock_type?
+          node.loc.end.line
+        elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
+          next_sibling.loc.line
+        elsif (parent = node.parent)
+          if parent.loc.respond_to?(:end) && parent.loc.end
+            parent.loc.end.line
+          else
+            parent.loc.line
+          end
+        end || node.loc.end.line
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -20,19 +20,30 @@ module RuboCop
         style_detected(possibilities)
       end
 
+      SYMBOL_TO_STRING_CACHE = Hash.new do |hash, key|
+        hash[key] = key.to_s if key.is_a?(Symbol)
+      end
+      private_constant :SYMBOL_TO_STRING_CACHE
+
+      # rubocop:disable Metrics
       def style_detected(detected)
         return if no_acceptable_style?
 
-        # `detected` can be a single style or an Array of possible styles
-        # (if there is more than one which matches the observed code)
-        detected_as_strings = Array(detected).map(&:to_s)
+        # This logic is more complex than it needs to be
+        # to avoid allocating Arrays in the hot code path.
+        updated_list =
+          if detected_style
+            if detected_style.size == 1 && detected_style.include?(SYMBOL_TO_STRING_CACHE[detected])
+              detected_style
+            else
+              detected_as_strings = SYMBOL_TO_STRING_CACHE.values_at(*detected)
+              detected_style & detected_as_strings
+            end
+          else
+            # We haven't observed any specific style yet.
+            SYMBOL_TO_STRING_CACHE.values_at(*detected)
+          end
 
-        updated_list = if detected_style
-                         detected_style & detected_as_strings
-                       else
-                         # We haven't observed any specific style yet.
-                         detected_as_strings
-                       end
         if updated_list.empty?
           no_acceptable_style!
         else
@@ -40,6 +51,7 @@ module RuboCop
           config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
+      # rubocop:enable Metrics
 
       def no_acceptable_style?
         config_to_allow_offenses['Enabled'] == false

data/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -18,6 +18,7 @@ module RuboCop
         alternative_styles.each do |alternative|
           return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
         end
+        unrecognized_style_detected
       end
 
       def valid_name?(node, name, given_style = style)

data/lib/rubocop/cop/mixin/def_node.rb

@@ -5,8 +5,7 @@ module RuboCop
     # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
-
-      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+      include VisibilityHelp
 
       private
 
@@ -15,16 +14,12 @@ module RuboCop
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
-      end
-
-      def stripped_source_upto(index)
-        processed_source[0..index].map(&:strip)
+        node_visibility(node) != :public
       end
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} ({def defs} ...))
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin/documentation_comment.rb

@@ -23,7 +23,7 @@ module RuboCop
       # The args node1 & node2 may represent a RuboCop::AST::Node
       # or a Parser::Source::Comment. Both respond to #loc.
       def preceding_comment?(node1, node2)
-        node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node

data/lib/rubocop/cop/mixin/duplication.rb

@@ -29,7 +29,7 @@ module RuboCop
       # @param [Array] collection an array to return consecutive duplicates for
       # @return [Array] the consecutive duplicates
       def consecutive_duplicates(collection)
-        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+        grouped_duplicates(collection).flat_map { |items| items[1..] }
       end
 
       # Returns a hash of grouped duplicates. The key will be the first

data/lib/rubocop/cop/mixin/end_keyword_alignment.rb

@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def variable_alignment?(whole_expression, rhs, end_alignment_style)
-        return if end_alignment_style == :keyword
+        return false if end_alignment_style == :keyword
 
         !line_break_before_keyword?(whole_expression, rhs)
       end

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -6,7 +6,8 @@ module RuboCop
     #
     # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
     # Rails department has been extracted to RuboCop Rails gem.
-    # This module is deprecated and will be removed by RuboCop 2.0.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
     # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
     # with existing RuboCop Rails 2.8 or lower.
     #

data/lib/rubocop/cop/mixin/first_element_line_break.rb

@@ -7,12 +7,12 @@ module RuboCop
     module FirstElementLineBreak
       private
 
-      def check_method_line_break(node, children)
+      def check_method_line_break(node, children, ignore_last: false)
         return if children.empty?
 
         return unless method_uses_parens?(node, children.first)
 
-        check_children_line_break(node, children)
+        check_children_line_break(node, children, ignore_last: ignore_last)
       end
 
       def method_uses_parens?(node, limit)
@@ -20,7 +20,7 @@ module RuboCop
         /\s*\(\s*$/.match?(source)
       end
 
-      def check_children_line_break(node, children, start = node)
+      def check_children_line_break(node, children, start = node, ignore_last: false)
         return if children.empty?
 
         line = start.first_line
@@ -28,8 +28,8 @@ module RuboCop
         min = first_by_line(children)
         return if line != min.first_line
 
-        max = last_by_line(children)
-        return if line == max.last_line
+        max_line = last_line(children, ignore_last: ignore_last)
+        return if line == max_line
 
         add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
@@ -38,8 +38,12 @@ module RuboCop
         nodes.min_by(&:first_line)
       end
 
-      def last_by_line(nodes)
-        nodes.max_by(&:last_line)
+      def last_line(nodes, ignore_last:)
+        if ignore_last
+          nodes.map(&:first_line)
+        else
+          nodes.map(&:last_line)
+        end.max
       end
     end
   end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -69,6 +69,10 @@ module RuboCop
         end
       end
 
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
       def leading_comment_lines
         first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
 

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -3,12 +3,28 @@
 module RuboCop
   module Cop
     # This module checks for Ruby 3.1's hash value omission syntax.
+    # rubocop:disable Metrics/ModuleLength
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
-      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
+      DO_NOT_MIX_MSG_PREFIX = 'Do not mix explicit and implicit hash values.'
+      DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
+      DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
+
+      def on_hash_for_mixed_shorthand(hash_node)
+        return if ignore_mixed_hash_shorthand_syntax?(hash_node)
+
+        hash_value_type_breakdown = breakdown_value_types_of_hash(hash_node)
+
+        if hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+          mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        else
+          no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        end
+      end
 
       def on_pair(node)
-        return if target_ruby_version <= 3.0
+        return if ignore_hash_shorthand_syntax?(node)
 
         hash_key_source = node.key.source
 
@@ -17,6 +33,7 @@ module RuboCop
 
           message = OMIT_HASH_VALUE_MSG
           replacement = "#{hash_key_source}:"
+          self.config_to_allow_offenses = { 'Enabled' => false }
         else
           return unless node.value_omission?
 
@@ -24,19 +41,49 @@ module RuboCop
           replacement = "#{hash_key_source}: #{hash_key_source}"
         end
 
+        register_offense(node, message, replacement)
+      end
+
+      private
+
+      def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         add_offense(node.value, message: message) do |corrector|
           corrector.replace(node, replacement)
+
+          next unless (def_node = def_node_that_require_parentheses(node))
+
+          last_argument = def_node.last_argument
+          if last_argument.nil? || !last_argument.hash_type?
+            next corrector.replace(node, replacement)
+          end
+
+          white_spaces = range_between(def_node.selector.end_pos,
+                                       def_node.first_argument.source_range.begin_pos)
+          next if node.parent.braces?
+
+          corrector.replace(white_spaces, '(')
+          corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
         end
       end
 
-      private
+      def ignore_mixed_hash_shorthand_syntax?(hash_node)
+        target_ruby_version <= 3.0 ||
+          !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
+          !hash_node.hash_type?
+      end
+
+      def ignore_hash_shorthand_syntax?(pair_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
+          !pair_node.parent.hash_type?
+      end
 
       def enforced_shorthand_syntax
         cop_config.fetch('EnforcedShorthandSyntax', 'always')
       end
 
       def require_hash_value?(hash_key_source, node)
-        return true if without_parentheses_call_expr_follows?(node)
+        return true if !node.key.sym_type? || require_hash_value_for_around_hash_literal?(node)
 
         hash_value = node.value
         return true unless hash_value.send_type? || hash_value.lvar_type?
@@ -44,13 +91,146 @@ module RuboCop
         hash_key_source != hash_value.source || hash_key_source.end_with?('!', '?')
       end
 
-      def without_parentheses_call_expr_follows?(node)
-        return false unless (ancestor = node.parent.parent)
-        return false unless (right_sibling = ancestor.right_sibling)
+      def require_hash_value_for_around_hash_literal?(node)
+        return false unless (method_dispatch_node = find_ancestor_method_dispatch_node(node))
+
+        !node.parent.braces? &&
+          !use_element_of_hash_literal_as_receiver?(method_dispatch_node, node.parent) &&
+          use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def def_node_that_require_parentheses(node)
+        last_pair = node.parent.pairs.last
+        return unless last_pair.key.source == last_pair.value.source
+        return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
+        return if dispatch_node.assignment_method?
+        return if dispatch_node.parenthesized?
+        return if dispatch_node.parent && parentheses?(dispatch_node.parent)
+        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
+
+        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
+
+        DefNode.new(def_node) unless def_node && def_node.arguments.empty?
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def find_ancestor_method_dispatch_node(node)
+        return unless (ancestor = node.parent.parent)
+        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return if brackets?(ancestor)
+
+        ancestor
+      end
+
+      def brackets?(method_dispatch_node)
+        method_dispatch_node.method?(:[]) || method_dispatch_node.method?(:[]=)
+      end
+
+      def use_element_of_hash_literal_as_receiver?(ancestor, parent)
+        # `{value:}.do_something` is a valid syntax.
+        ancestor.send_type? && ancestor.receiver == parent
+      end
+
+      def use_modifier_form_without_parenthesized_method_call?(ancestor)
+        return false if ancestor.respond_to?(:parenthesized?) && ancestor.parenthesized?
+
+        ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
+      end
 
-        ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? &&
-          right_sibling.respond_to?(:parenthesized?) && !right_sibling.parenthesized?
+      def last_expression?(node)
+        return false if node.right_sibling
+        return true unless (assignment_node = node.each_ancestor.find(&:assignment?))
+        return last_expression?(assignment_node.parent) if assignment_node.parent&.assignment?
+
+        !assignment_node.right_sibling
+      end
+
+      def method_dispatch_as_argument?(method_dispatch_node)
+        parent = method_dispatch_node.parent
+        return false unless parent
+
+        parent.call_type? || parent.super_type? || parent.yield_type?
+      end
+
+      def breakdown_value_types_of_hash(hash_node)
+        hash_node.pairs.group_by do |pair_node|
+          if pair_node.value_omission?
+            :value_omitted
+          elsif require_hash_value?(pair_node.key.source, pair_node)
+            :value_needed
+          else
+            :value_omittable
+          end
+        end
+      end
+
+      def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys.size > 1
+      end
+
+      def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        hash_value_type_breakdown[:value_needed]&.any?
+      end
+
+      def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys == [:value_omittable] &&
+          enforced_shorthand_syntax == 'either_consistent'
+      end
+
+      def each_omitted_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omitted]&.each(&block)
+      end
+
+      def each_omittable_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omittable]&.each(&block)
+      end
+
+      def mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+          each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}: #{hash_key_source}"
+            register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
+          end
+        else
+          each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}:"
+            register_offense(pair_node, DO_NOT_MIX_OMIT_VALUE_MSG, replacement)
+          end
+        end
+      end
+
+      def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        return if ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown)
+
+        each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+          hash_key_source = pair_node.key.source
+          replacement = "#{hash_key_source}:"
+          register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
+        end
+      end
+
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
       end
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -14,7 +14,7 @@ module RuboCop
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
 
-      def on_block(node)
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -68,6 +68,8 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
+        return unless captures.use_transformed_argname?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,11 +115,7 @@ module RuboCop
       end
 
       # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr,
-        :unchanged_body_expr
-      ) do
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
         def noop_transformation?
           transforming_body_expr.lvar_type? &&
             transforming_body_expr.children == [transformed_argname]
@@ -126,6 +124,12 @@ module RuboCop
         def transformation_uses_both_args?
           transforming_body_expr.descendants.include?(unchanged_body_expr)
         end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
       end
 
       # Internal helper class to hold autocorrect data
@@ -155,7 +159,7 @@ module RuboCop
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         end
@@ -171,11 +175,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.loc.expression.source
+          body_source = transforming_body_expr.source
           if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
             body_source = "{ #{body_source} }"
           end