rubocop 1.91.0 → 1.92.1

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

@@ -96,15 +96,22 @@ module RuboCop
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
+      # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
-        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+        if unparenthesized_call_with_omitted_value?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        elsif (value = wrapped_value(if_body))
+          prefix = if_body.source_range.begin.join(value.source_range.begin).source
+          suffix = value.source_range.end.join(if_body.source_range.end).source
+
+          "#{prefix}#{if_body_source(value)}#{suffix}"
         else
           if_body.source
         end
       end
 
-      def omitted_value_in_last_hash_arg?(if_body)
+      def unparenthesized_call_with_omitted_value?(if_body)
+        return false if !if_body.call_type? || if_body.method?(:[]=) || if_body.parenthesized?
         return false unless (last_argument = if_body.last_argument)
 
         last_argument.hash_type? && last_argument.pairs.last&.value_omission?
@@ -116,6 +123,14 @@ module RuboCop
         if_body.source_range.begin.join(end_range).source
       end
 
+      def wrapped_value(if_body)
+        if if_body.type?(:return, :next, :break)
+          if_body.first_argument if if_body.arguments.one?
+        elsif if_body.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn)
+          if_body.expression
+        end
+      end
+
       def first_line_comment(node)
         comment = processed_source.comment_at_line(node.first_line)
         return unless comment
@@ -137,9 +152,15 @@ module RuboCop
         parent = node.parent
         return false if parent.nil?
         return true if parent.assignment? || parent.operator_keyword?
-        return true if %i[array pair].include?(parent.type)
+        return true if parent.type?(:array, :pair, :call, :yield, :super)
+
+        ternary_branch_or_endless_method_body?(parent)
+      end
+
+      def ternary_branch_or_endless_method_body?(parent)
+        return parent.ternary? if parent.if_type?
 
-        node.parent.send_type?
+        parent.any_def_type? && parent.endless?
       end
 
       def comment_disables_cop?(comment)

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

@@ -63,9 +63,10 @@ module RuboCop
         (send nil? VISIBILITY_SCOPES def)
       PATTERN
 
+      # A modifier applies to every symbol it is given, not only to a sole argument.
       # @!method visibility_inline_on_method_name?(node, method_name:)
       def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
-        (send nil? VISIBILITY_SCOPES (sym %method_name))
+        (send nil? VISIBILITY_SCOPES <(sym %method_name) ...>)
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin.rb

@@ -32,6 +32,7 @@ module RuboCop
     autoload :AnnotationComment, "#{__dir__}/mixin/annotation_comment"
     autoload :EmptyParameter, "#{__dir__}/mixin/empty_parameter"
     autoload :EndKeywordAlignment, "#{__dir__}/mixin/end_keyword_alignment"
+    autoload :EndlessMethodBodyHelp, "#{__dir__}/mixin/endless_method_body_help"
     autoload :EndlessMethodRewriter, "#{__dir__}/mixin/endless_method_rewriter"
     autoload :EnforceSuperclass, "#{__dir__}/mixin/enforce_superclass"
     autoload :FirstElementLineBreak, "#{__dir__}/mixin/first_element_line_break"
@@ -64,6 +65,7 @@ module RuboCop
     autoload :OnNormalIfUnless, "#{__dir__}/mixin/on_normal_if_unless"
     autoload :OrderedGemNode, "#{__dir__}/mixin/ordered_gem_node"
     autoload :Parentheses, "#{__dir__}/mixin/parentheses"
+    autoload :PatternMatchingHelp, "#{__dir__}/mixin/pattern_matching_help"
     autoload :PercentArray, "#{__dir__}/mixin/percent_array"
     autoload :PercentLiteral, "#{__dir__}/mixin/percent_literal"
     autoload :PrecedingFollowingAlignment, "#{__dir__}/mixin/preceding_following_alignment"

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -80,22 +80,6 @@ module RuboCop
             node.arguments.one? &&
             node.first_argument.arg_type?
         end
-
-        # When `AllCops/UseProjectIndex` is enabled, methods that override a
-        # method defined by an ancestor elsewhere in the project are not
-        # reported: renaming an override breaks the inherited contract.
-        def overrides_inherited_method?(node)
-          return false unless project_index
-          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
-
-          declaration = resolve_constant_in_index(namespace_node.identifier)
-          return false unless declaration.is_a?(Rubydex::Namespace)
-
-          scope = node.defs_type? ? indexed_singleton_of(declaration) : declaration
-          !scope.nil? && inherited_index_member?(scope, "#{node.method_name}()")
-        rescue StandardError
-          false
-        end
       end
     end
   end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -63,7 +63,7 @@ module RuboCop
 
         def self.autocorrect_incompatible_with
           [
-            Lint::AmbiguousOperator, Style::ArgumentsForwarding,
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::EndlessMethod,
             Style::ExplicitBlockArgument, Style::MethodDefParentheses
           ]
         end

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -35,7 +35,7 @@ module RuboCop
         MSG = 'Use %<style>s heredoc delimiters.'
 
         def on_heredoc(node)
-          return if correct_case_delimiters?(node)
+          return if correct_case_delimiters?(node) || corrected_delimiter_in_body?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
             expr = node.source_range
@@ -52,7 +52,14 @@ module RuboCop
         end
 
         def correct_case_delimiters?(node)
-          delimiter_string(node) == correct_delimiters(delimiter_string(node))
+          delimiters = delimiter_string(node)
+          delimiters == correct_delimiters(delimiters)
+        end
+
+        def corrected_delimiter_in_body?(node)
+          corrected = correct_delimiters(delimiter_string(node))
+
+          node.loc.heredoc_body.source.each_line.any? { |line| line.strip == corrected }
         end
 
         def correct_delimiters(source)

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -43,9 +43,11 @@ module RuboCop
 
           return false unless /\w/.match?(delimiters)
 
-          forbidden_delimiters.none? do |forbidden_delimiter|
-            Regexp.new(forbidden_delimiter).match?(delimiters)
-          end
+          forbidden_delimiter_regexps.none? { |regexp| regexp.match?(delimiters) }
+        end
+
+        def forbidden_delimiter_regexps
+          @forbidden_delimiter_regexps ||= forbidden_delimiters.map { |d| Regexp.new(d) }
         end
 
         def forbidden_delimiters

data/lib/rubocop/cop/naming/predicate_prefix.rb

@@ -142,12 +142,6 @@ module RuboCop
           end
         end
 
-        def offending_prefixes_for(node, method_name)
-          predicate_prefixes.reject do |prefix|
-            allowed_method_name?(method_name, prefix) ||
-              (use_sorbet_sigs? && !sorbet_sig?(node, return_type: 'T::Boolean'))
-          end
-        end
         alias on_defs on_def
 
         def validate_config
@@ -162,6 +156,13 @@ module RuboCop
 
         private
 
+        def offending_prefixes_for(node, method_name)
+          prefixes = predicate_prefixes.reject { |p| allowed_method_name?(method_name, p) }
+          return prefixes if prefixes.empty? || !use_sorbet_sigs?
+
+          sorbet_sig?(node, return_type: 'T::Boolean') ? prefixes : []
+        end
+
         # @!method sorbet_return_type(node)
         def_node_matcher :sorbet_return_type, <<~PATTERN
           (block (send nil? :sig) args (send _ :returns $_type))
@@ -210,22 +211,6 @@ module RuboCop
         def method_definition_macro?(macro_name)
           cop_config['MethodDefinitionMacros'].include?(macro_name.to_s)
         end
-
-        # When `AllCops/UseProjectIndex` is enabled, methods that override a
-        # method defined by an ancestor elsewhere in the project are not
-        # reported: renaming an override breaks the inherited contract.
-        def overrides_inherited_method?(node)
-          return false unless project_index
-          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
-
-          declaration = resolve_constant_in_index(namespace_node.identifier)
-          return false unless declaration.is_a?(Rubydex::Namespace)
-
-          scope = node.defs_type? ? indexed_singleton_of(declaration) : declaration
-          !scope.nil? && inherited_index_member?(scope, "#{node.method_name}()")
-        rescue StandardError
-          false
-        end
       end
     end
   end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -128,7 +128,7 @@ module RuboCop
             if child_node.lvar_type?
               parent_node = child_node.parent
               if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
-                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+                corrector.replace(parent_node.loc.operator, ": #{preferred_name}")
               else
                 corrector.replace(child_node, preferred_name)
               end

data/lib/rubocop/cop/offense.rb

@@ -86,6 +86,9 @@ module RuboCop
 
       NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
+      EMPTY_CORRECTIONS = [].freeze
+      private_constant :EMPTY_CORRECTIONS
+
       # @api public
       #
       # @!attribute [r] justification
@@ -96,9 +99,43 @@ module RuboCop
       #   or the directive carries no reason
       attr_reader :justification
 
+      # @api public
+      #
+      # @!attribute [r] corrections
+      #
+      # @return [Array<Correction>]
+      #   the individual edits that autocorrecting this offense would make, in
+      #   source order. Empty when the offense has no correction. Unlike
+      #   {#corrector}, this survives serialization, so it is available on a
+      #   cache hit and in parallel runs.
+      attr_reader :corrections
+
+      # @api public
+      #
+      # @!attribute [r] correction_safe
+      #
+      # @return [Boolean]
+      #   whether autocorrection would apply {#corrections} in a normal `-a`
+      #   run. A cop marked `Safe: false` or `SafeAutoCorrect: false` still
+      #   builds its correction, but only `-A` applies it, so a consumer that
+      #   applies edits itself has to make the same distinction.
+      attr_reader :correction_safe
+
+      # A single edit of an autocorrection: the source range it replaces and
+      # the text it replaces it with. An insertion has an empty range, a
+      # removal an empty replacement.
+      #
+      # @api public
+      Correction = Struct.new(:begin_pos, :end_pos, :replacement) do
+        def length
+          end_pos - begin_pos
+        end
+      end
+
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists
-                     status = :uncorrected, corrector = nil, justification: nil)
+                     status = :uncorrected, corrector = nil, justification: nil,
+                     corrections: nil, correction_safe: true)
         @severity = RuboCop::Cop::Severity.new(severity)
         @location = location
 
@@ -112,15 +149,21 @@ module RuboCop
         @status = status
         @corrector = corrector
         @justification = justification.freeze
+        @corrections = (corrections || corrections_from(corrector)).freeze
+        @correction_safe = correction_safe
         freeze
       end
 
       def marshal_dump
-        [@severity, @location, @message, @cop_name, @status, @justification]
+        [@severity, @location, @message, @cop_name, @status, @justification, @corrections,
+         @correction_safe]
       end
 
       def marshal_load(array)
-        @severity, @location, @message, @cop_name, @status, @justification = array
+        @severity, @location, @message, @cop_name, @status, @justification, @corrections,
+          @correction_safe = array
+        @corrections ||= EMPTY_CORRECTIONS
+        @correction_safe = true if @correction_safe.nil?
         @line = @location.line
         @column = @location.column
       end
@@ -276,6 +319,19 @@ module RuboCop
         end
         0
       end
+
+      private
+
+      # Extracted eagerly rather than on demand because the offense is frozen,
+      # and because a corrector cannot be serialized - the cache and parallel
+      # workers would otherwise hand back offenses that have lost their edits.
+      def corrections_from(corrector)
+        return EMPTY_CORRECTIONS unless corrector
+
+        corrector.as_replacements.map do |range, replacement|
+          Correction.new(range.begin_pos, range.end_pos, replacement.freeze).freeze
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/registry.rb

@@ -43,7 +43,7 @@ module RuboCop
 
       def self.qualified_cop?(name)
         badge = Badge.parse(name)
-        global.qualify_badge(badge).first == badge
+        global.qualify_badge(badge).include?(badge)
       end
 
       attr_reader :options, :warnings

data/lib/rubocop/cop/security/json_load.rb

@@ -22,6 +22,13 @@ module RuboCop
       # passing the `create_additions` keyword argument emits a deprecation warning, with the
       # goal of being secure by default in the next major version 3.0.0.
       #
+      # NOTE: Before `json` gem version 2.17.0, `JSON.load` only takes options as its third
+      # argument. A hash passed as the second argument is taken as the `proc` argument, so
+      # its `create_additions` option is ignored. Which `json` version runs can't be told
+      # statically (the lockfile may resolve a newer one than the default gem loaded in
+      # production), so options passed as the second argument are always reported. Pass
+      # `nil` as the second argument instead.
+      #
       # @safety
       #   This cop's autocorrection is unsafe because it's potentially dangerous.
       #   If using a stream, like `JSON.load(open('file'))`, you will need to call
@@ -33,13 +40,16 @@ module RuboCop
       #   JSON.load('{}')
       #   JSON.restore('{}')
       #
+      #   # bad - ignored by `json` older than 2.17.0
+      #   JSON.load('{}', create_additions: false)
+      #
       #   # good
       #   JSON.parse('{}')
       #   JSON.unsafe_load('{}')
       #
       #   # good - explicit use of `create_additions` option
-      #   JSON.load('{}', create_additions: true)
-      #   JSON.load('{}', create_additions: false)
+      #   JSON.load('{}', nil, create_additions: true)
+      #   JSON.load('{}', nil, create_additions: false)
       #
       class JSONLoad < Base
         extend AutoCorrector
@@ -51,8 +61,10 @@ module RuboCop
         def_node_matcher :insecure_json_load, <<~PATTERN
           (
             send (const {nil? cbase} :JSON) ${:load :restore}
-            ...
-            !`(pair (sym :create_additions) _)
+            {
+              _ hash
+            | ... !`(pair (sym :create_additions) _)
+            }
           )
         PATTERN
 

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

@@ -132,10 +132,11 @@ module RuboCop
       #     private alias_method :qux, :foo
       #
       #   end
-      class AccessModifierDeclarations < Base
+      class AccessModifierDeclarations < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
 
         include ConfigurableEnforcedStyle
+        include EndlessMethodBodyHelp
         include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
@@ -169,6 +170,10 @@ module RuboCop
             (send nil? :alias_method _ _))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::EndlessMethod, Style::SingleLineMethods]
+        end
+
         def on_send(node)
           return if allowed?(node)
 
@@ -187,11 +192,18 @@ module RuboCop
         def allowed?(node)
           !node.access_modifier? ||
             node.parent&.type?(:pair, :any_block) ||
+            dynamic_method_list?(node) ||
             allow_modifiers_on_symbols?(node) ||
             allow_modifiers_on_attrs?(node) ||
             allow_modifiers_on_alias_method?(node)
         end
 
+        # `private(*names)` with a list computed at runtime names no definition
+        # the modifier could be grouped with.
+        def dynamic_method_list?(node)
+          node.arguments.any?(&:splat_type?) && !access_modifier_with_symbol?(node)
+        end
+
         def autocorrect(corrector, node)
           case style
           when :group
@@ -241,10 +253,33 @@ module RuboCop
 
             access_modifier_is_inlined?(node) && !right_siblings_same_inline_method?(node)
           else
-            access_modifier_is_not_inlined?(node) && select_grouped_def_nodes(node).any?
+            access_modifier_is_not_inlined?(node) && inlinable?(select_grouped_def_nodes(node))
           end
         end
 
+        def inlinable?(def_nodes)
+          return false if def_nodes.empty?
+
+          def_nodes.none? { |def_node| def_node.endless? && body_unsafe_to_inline?(def_node.body) }
+        end
+
+        def body_unsafe_to_inline?(body)
+          return true if body.each_node(:any_block).any? { |block| do_end_block?(block) }
+
+          target_ruby_version < 4.0 && command_body?(body)
+        end
+
+        def do_end_block?(block)
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+
+        def command_body?(body)
+          body = body.body while body.rescue_type?
+          return true if body.send_type? && body.prefix_not? && !body.parenthesized?
+
+          command_call?(body)
+        end
+
         def correctable_group_offense?(node)
           return false unless group_style?
           return false if allowed?(node)

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

@@ -60,7 +60,7 @@ module RuboCop
             add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
               autocorrect(corrector, node)
             end
-          elsif node.children.none? { |arg| bareword?(arg) }
+          elsif node.children.all? { |arg| !bareword?(arg) && bareword_symbol?(arg) }
             add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
@@ -97,7 +97,7 @@ module RuboCop
 
         def add_offense_for_args(node, &block)
           existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..] }.join(' ')
+          preferred_args = node.children.map { |node| bareword_for(node) }.join(' ')
           arg_ranges     = node.children.map(&:source_range)
           msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
           add_offense(arg_ranges.reduce(&:join), message: msg, &block)
@@ -138,6 +138,15 @@ module RuboCop
           !sym_node.source.start_with?(':') || sym_node.dsym_type?
         end
 
+        def bareword_symbol?(sym_node)
+          return false unless sym_node.sym_type?
+
+          value = sym_node.value.to_s
+          return true if value.match?(/\A[A-Za-z_]\w*[?!=]?\z/)
+
+          !sym_node.source.start_with?(':"', ":'") && !value.start_with?('@', '$')
+        end
+
         def correct_alias_method_to_alias(corrector, send_node)
           new, old = *send_node.arguments
           replacement = "alias #{identifier(new)} #{identifier(old)}"
@@ -153,17 +162,21 @@ module RuboCop
         end
 
         def correct_alias_with_symbol_args(corrector, node)
-          corrector.replace(node.new_identifier, node.new_identifier.source[1..])
-          corrector.replace(node.old_identifier, node.old_identifier.source[1..])
+          corrector.replace(node.new_identifier, bareword_for(node.new_identifier))
+          corrector.replace(node.old_identifier, bareword_for(node.old_identifier))
         end
 
         def identifier(node)
-          if node.sym_type?
+          if bareword_symbol?(node)
             ":#{node.children.first}"
           else
             node.source
           end
         end
+
+        def bareword_for(sym_node)
+          sym_node.value.to_s
+        end
       end
     end
   end

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

@@ -39,9 +39,9 @@ module RuboCop
         # @!method ambiguous_endless_method_body(node)
         def_node_matcher :ambiguous_endless_method_body, <<~PATTERN
           ^${
-            (if _ <def _>)
-            ({and or} def _)
-            ({while until} _ def)
+            (if _ <any_def _>)
+            ({and or} any_def _)
+            ({while until} _ any_def)
           }
         PATTERN
 
@@ -57,6 +57,7 @@ module RuboCop
             correct_to_multiline(corrector, node)
           end
         end
+        alias on_defs on_def
 
         private
 

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

@@ -48,6 +48,10 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::ReturnNil, Style::ReturnNilInPredicateMethodDefinition]
+        end
+
         def on_and(node)
           process_logical_operator(node) if style == :always
         end
@@ -69,7 +73,7 @@ module RuboCop
           message = message(node)
           add_offense(node.loc.operator, message: message) do |corrector|
             node.each_child_node do |expr|
-              if expr.send_type?
+              if expr.call_type?
                 correct_send(expr, corrector)
               elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
                 correct_other(expr, corrector)
@@ -116,7 +120,7 @@ module RuboCop
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
           if node.prefix_bang?
-            return unless receiver.send_type?
+            return unless receiver.call_type?
 
             correct_send(receiver, corrector)
           elsif node.prefix_not?

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

@@ -153,7 +153,7 @@ module RuboCop
         BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding, Style::MethodDefParentheses]
+          [Naming::BlockForwarding, Style::EndlessMethod, Style::MethodDefParentheses]
         end
 
         def on_def(node)
@@ -169,7 +169,7 @@ module RuboCop
 
           return if send_classifications.empty?
 
-          if only_forwards_all?(send_classifications)
+          if forward_all?(send_nodes, send_classifications)
             add_forward_all_offenses(node, send_classifications, forwardable_args)
           elsif target_ruby_version >= 3.2
             add_post_ruby_32_offenses(node, send_classifications, forwardable_args)
@@ -192,11 +192,33 @@ module RuboCop
           [restarg_node, kwrestarg_node, blockarg_node]
         end
 
+        def forward_all?(send_nodes, send_classifications)
+          only_forwards_all?(send_classifications) &&
+            !anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+        end
+
         def only_forwards_all?(send_classifications)
           all_classifications = %i[all all_anonymous].freeze
           send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
+        def anonymous_forwarding_elsewhere?(send_nodes, send_classifications)
+          classified = send_classifications.map(&:first)
+
+          send_nodes.any? do |send_node|
+            classified.none? { |node| node.equal?(send_node) } &&
+              forwards_anonymous_args?(send_node)
+          end
+        end
+
+        def forwards_anonymous_args?(send_node)
+          send_node.arguments.any? do |arg|
+            next arg.children.any?(&:forwarded_kwrestarg_type?) if arg.hash_type?
+
+            arg.forwarded_restarg_type?
+          end
+        end
+
         # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
           rest_arg, kwrest_arg, block_arg = *forwardable_args
@@ -376,11 +398,16 @@ module RuboCop
 
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
-          return if node.send_type? && node.method?(:[])
+          return if node.call_type? && operator_or_setter_call?(node)
+          return unless (@parenthesized_nodes ||= Set.new.compare_by_identity).add?(node)
 
           add_parentheses(node, corrector)
         end
 
+        def operator_or_setter_call?(node)
+          node.setter_method? || (node.operator_method? && !node.loc.dot)
+        end
+
         # Classifies send nodes for possible rest/kwrest/all (including block) forwarding.
         class SendNodeClassifier
           extend NodePattern::Macros
@@ -499,6 +526,8 @@ module RuboCop
           end
 
           def offensive_block_forwarding?
+            return false if @send_node.block_literal?
+
             @block_arg ? forwarded_block_arg : allow_offense_for_no_block?
           end
 

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

@@ -50,10 +50,9 @@ module RuboCop
         def autocorrect(corrector, node)
           attr_name, setter = *node.arguments
 
-          node_expr = node.source_range
-          attr_expr = attr_name.source_range
-
-          remove = range_between(attr_expr.end_pos, node_expr.end_pos) if setter&.boolean_type?
+          if setter&.boolean_type?
+            remove = range_between(attr_name.source_range.end_pos, setter.source_range.end_pos)
+          end
 
           corrector.replace(node.loc.selector, replacement_method(node))
           corrector.remove(remove) if remove