rubocop 1.92.0 → 1.92.2

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

@@ -49,7 +49,7 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses, Style::ReturnNilInPredicateMethodDefinition]
+          [Style::MethodCallWithArgsParentheses, Style::ReturnNil, Style::ReturnNilInPredicateMethodDefinition]
         end
 
         def on_and(node)
@@ -72,13 +72,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?
-                correct_send(expr, corrector)
-              elsif expr.type?(:return, :next, :break, :yield) || expr.assignment?
-                correct_other(expr, corrector)
-              end
-            end
+            node.each_child_node { |expr| correct_operand(expr, corrector) }
 
             corrector.replace(node.loc.operator, node.alternate_operator)
 
@@ -86,6 +80,22 @@ module RuboCop
           end
         end
 
+        def correct_operand(expr, corrector)
+          expr = expr.send_node if expr.any_block_type?
+
+          if expr.type?(:call, :super)
+            correct_send(expr, corrector)
+          elsif wrap_in_parentheses?(expr)
+            correct_other(expr, corrector)
+          end
+        end
+
+        # These bind looser than `&&` and `||`, or can't be their operands at all.
+        def wrap_in_parentheses?(node)
+          node.type?(:return, :next, :break, :yield, :any_match_pattern, :range, :defined?) ||
+            node.assignment? || (node.if_type? && node.ternary?)
+        end
+
         def on_conditionals(node)
           node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
             process_logical_operator(operator)
@@ -101,6 +111,7 @@ module RuboCop
           return correct_setter(node, corrector) if node.setter_method?
           return correct_other(node, corrector) if node.comparison_method?
 
+          correct_block_receiver(node, corrector)
           return unless correctable_send?(node)
 
           whitespace_before_arg_range = whitespace_before_arg(node)
@@ -120,7 +131,8 @@ 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?
+            receiver = receiver.send_node if receiver.any_block_type?
+            return unless receiver.type?(:call, :super)
 
             correct_send(receiver, corrector)
           elsif node.prefix_not?
@@ -145,12 +157,23 @@ module RuboCop
           end
         end
 
+        # A method chained onto a `do` block, as in `bar baz do ... end.qux`,
+        # still needs parentheses around the arguments of the call that takes the block.
+        def correct_block_receiver(node, corrector)
+          receiver = node.receiver
+          receiver = receiver.receiver while receiver&.call_type?
+          correct_operand(receiver, corrector) if receiver&.any_block_type?
+        end
+
         def correctable_send?(node)
-          !node.parenthesized? && node.arguments? && !node.method?(:[])
+          # Operator syntax such as `a + b` or `a[b]` already binds tighter than `&&` and `||`.
+          return false if node.operator_method? && !node.loc.dot
+
+          !node.parenthesized? && node.arguments?
         end
 
         def whitespace_before_arg(node)
-          begin_paren = node.loc.selector.end_pos
+          begin_paren = node.selector.end_pos
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).

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

@@ -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,12 +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

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

@@ -306,6 +306,8 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
+          return if directive_comment?(comment)
+
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
 
           # It is possible that there is code between the block and the comment
@@ -319,6 +321,10 @@ module RuboCop
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def directive_comment?(comment)
+          comment.text.match?(DirectiveComment::DIRECTIVE_COMMENT_REGEXP)
+        end
+
         def source_range_before_comment(range, comment)
           range = range.end.join(comment.source_range.begin)
 

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

@@ -7,7 +7,7 @@ module RuboCop
       # The `===` operator has different behavior depending on the
       # receiver and its use outside of `case`/`when` is confusing.
       # Prefer more explicit alternatives like `is_a?`, `include?`,
-      # or `match?`.
+      # `cover?`, or `match?`.
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
@@ -22,9 +22,11 @@ module RuboCop
       # @example
       #   # bad
       #   (1..100) === 7
+      #   ('a'..'z') === char
       #
       #   # good
       #   (1..100).include?(7)
+      #   ('a'..'z').cover?(char)
       #
       # @example AllowOnConstant: false (default)
       #   # bad
@@ -90,9 +92,18 @@ module RuboCop
         end
 
         def begin_replacement(lhs, rhs)
-          return unless lhs.children.first&.range_type?
+          range = lhs.children.first
+          return unless range&.range_type?
 
-          "#{lhs.source}.include?(#{rhs.source})"
+          method = cover_semantics?(range) ? 'cover?' : 'include?'
+
+          "#{lhs.source}.#{method}(#{rhs.source})"
+        end
+
+        # `Range#===` behaves like `Range#cover?` since Ruby 2.7 (since Ruby 2.6 for ranges
+        # that aren't string ranges), and `Range#include?` only matches that for numeric ranges.
+        def cover_semantics?(range)
+          target_ruby_version >= 2.7 && !range.children.compact.all?(&:numeric_type?)
         end
 
         def const_replacement(lhs, rhs)

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

@@ -65,10 +65,11 @@ module RuboCop
         NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
-        # `Style/StructInheritance` turns a class definition into a constant assignment in
-        # the same pass, which the compacted `class` keyword would then precede.
+        # `Style/StructInheritance` and `Style/DataInheritance` turn a class definition into
+        # a constant assignment in the same pass, which the compacted `class` keyword would
+        # then precede.
         def self.autocorrect_incompatible_with
-          [Style::StructInheritance]
+          [Style::DataInheritance, Style::StructInheritance]
         end
 
         def on_class(node)
@@ -152,7 +153,9 @@ module RuboCop
           # making autocorrection ping-pong between the two forms.
           return if style_for_kind(node.body.type) == :nested
           return unless compactible_namespace?(node)
+          return if node.each_ancestor(:class, :module).any? { |ancestor| ignored_node?(ancestor) }
 
+          ignore_node(node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
           unindent(corrector, node)

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

@@ -75,7 +75,10 @@ module RuboCop
           return unless def_nodes(node).all? { |def_node| no_code_after?(def_node.source_range) }
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
+            next if inside_corrected_sclass?(node)
+
             autocorrect_sclass(node, corrector)
+            ignore_node(node)
           end
         end
 
@@ -120,6 +123,10 @@ module RuboCop
           trailing.empty? || trailing.start_with?('#')
         end
 
+        def inside_corrected_sclass?(node)
+          node.each_ancestor(:sclass).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def autocorrect_sclass(node, corrector)
           rewritten_defs = []
 

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

@@ -15,31 +15,24 @@ module RuboCop
       # would yield false positives. For example, `String` implements `length`
       # and `size`, but it doesn't include `Enumerable`.
       #
+      # When `count` is used without a block, it measures the collection's
+      # size, so the offense is corrected to `empty?` or `!empty?`. The
+      # predicate methods `any?`, `none?` and `one?` test element truthiness
+      # instead and would return different results for collections with falsey
+      # elements (e.g. `[false].count.zero?` is `false`, but `[false].none?`
+      # is `true`). For the same reason, `count == 1` and `count > 1` without
+      # a block are not flagged.
+      #
       # @safety
       #   The cop is unsafe because receiver might not include `Enumerable`, or
       #   it has nonstandard implementation of `count` or any replacement
       #   methods.
       #
-      #   It's also unsafe because for collections with falsey values, expressions
-      #   with `count` without a block return a different result than methods `any?`,
-      #   `none?` and `one?`:
-      #
-      #   [source,ruby]
-      #   ----
-      #   [nil, false].count.positive?
-      #   [nil].count == 1
-      #   # => true
-      #
-      #   [nil, false].any?
-      #   [nil].one?
-      #   # => false
-      #
-      #   [nil].count == 0
-      #   # => false
-      #
-      #   [nil].none?
-      #   # => true
-      #   ----
+      #   Blockless `count` is corrected to `empty?`, which `Enumerable` doesn't
+      #   define. `Range`, `Enumerator` (including lazy ones), `Struct`, `StringIO`
+      #   and any class that just includes `Enumerable` respond to `count` but not
+      #   to `empty?`, so `(1...1).count.zero?` is `true` while `(1...1).empty?`
+      #   raises `NoMethodError`.
       #
       #   Autocorrection is unsafe when replacement methods don't iterate over
       #   every element in collection and the given block runs side effects:
@@ -60,12 +53,14 @@ module RuboCop
       #   x.count > 0
       #   x.count != 0
       #
+      #   # good
+      #   !x.empty?
+      #
+      #   # bad
       #   x.count(&:foo?).positive?
       #   x.count { |item| item.foo? }.positive?
       #
       #   # good
-      #   x.any?
-      #
       #   x.any?(&:foo?)
       #   x.any? { |item| item.foo? }
       #
@@ -74,24 +69,33 @@ module RuboCop
       #   x.count == 0
       #
       #   # good
-      #   x.none?
+      #   x.empty?
       #
       #   # bad
-      #   x.count == 1
-      #   x.one?
+      #   x.count(&:foo?).zero?
+      #   x.count(&:foo?) == 0
+      #
+      #   # good
+      #   x.none?(&:foo?)
+      #
+      #   # bad
+      #   x.count(&:foo?) == 1
+      #
+      #   # good
+      #   x.one?(&:foo?)
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #
       #   # bad
-      #   x.count > 1
+      #   x.count(&:foo?) > 1
       #
       #   # good
-      #   x.many?
+      #   x.many?(&:foo?)
       #
       class CollectionQuerying < Base
         include RangeHelp
@@ -102,13 +106,21 @@ module RuboCop
         RESTRICT_ON_SEND = %i[positive? > != zero? ==].freeze
 
         REPLACEMENTS = {
-          [:positive?, nil] => :any?,
-          [:>, 0] => :any?,
-          [:!=, 0] => :any?,
-          [:zero?, nil] => :none?,
-          [:==, 0] => :none?,
-          [:==, 1] => :one?,
-          [:>, 1] => :many?
+          [:positive?, nil] => 'any?',
+          [:>, 0] => 'any?',
+          [:!=, 0] => 'any?',
+          [:zero?, nil] => 'none?',
+          [:==, 0] => 'none?',
+          [:==, 1] => 'one?',
+          [:>, 1] => 'many?'
+        }.freeze
+
+        NO_BLOCK_REPLACEMENTS = {
+          [:positive?, nil] => '!empty?',
+          [:>, 0] => '!empty?',
+          [:!=, 0] => '!empty?',
+          [:zero?, nil] => 'empty?',
+          [:==, 0] => 'empty?'
         }.freeze
 
         # @!method count_predicate(node)
@@ -132,28 +144,49 @@ module RuboCop
         def on_send(node)
           return unless (count_node = count_predicate(node))
 
-          replacement_method = replacement_method(node)
+          replacement = replacement_method(node, count_node)
 
-          return unless replacement_supported?(replacement_method)
+          return unless replacement_supported?(node, replacement)
 
           offense_range = count_node.loc.selector.join(node.source_range.end)
-          add_offense(offense_range,
-                      message: format(MSG, prefer: replacement_method)) do |corrector|
-            corrector.replace(count_node.loc.selector, replacement_method)
-            corrector.remove(removal_range(node))
+          add_offense(offense_range, message: format(MSG, prefer: replacement)) do |corrector|
+            autocorrect(corrector, node, count_node, replacement)
           end
         end
 
         private
 
-        def replacement_method(node)
-          REPLACEMENTS.fetch([node.method_name, node.first_argument&.value])
+        def replacement_method(node, count_node)
+          key = [node.method_name, node.first_argument&.value]
+          return REPLACEMENTS.fetch(key) if block_given_to_count?(count_node)
+
+          NO_BLOCK_REPLACEMENTS[key]
+        end
+
+        def block_given_to_count?(count_node)
+          count_node.parent&.any_block_type? || count_node.last_argument&.block_pass_type?
+        end
+
+        def replacement_supported?(node, replacement)
+          return false unless replacement
+          return false if replacement == 'many?' && !active_support_extensions_enabled?
+
+          !(replacement.start_with?('!') && receiver_of_call?(node))
         end
 
-        def replacement_supported?(method_name)
-          return true if active_support_extensions_enabled?
+        def receiver_of_call?(node)
+          node.parent&.call_type? && node.parent.receiver == node && node.parent.loc.dot
+        end
+
+        def autocorrect(corrector, node, count_node, replacement)
+          if replacement.start_with?('!')
+            corrector.insert_before(count_node, '!')
+            corrector.replace(count_node.loc.selector, 'empty?')
+          else
+            corrector.replace(count_node.loc.selector, replacement)
+          end
 
-          method_name != :many?
+          corrector.remove(removal_range(node))
         end
 
         def removal_range(node)

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

@@ -65,6 +65,10 @@ module RuboCop
 
         MSG = 'Combine this loop with the previous loop.'
 
+        def self.autocorrect_incompatible_with
+          [Layout::BlockEndNewline, Layout::RedundantLineBreak]
+        end
+
         def on_block(node)
           return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)

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

@@ -118,7 +118,8 @@ module RuboCop
           # A comment or a heredoc body there can't be moved out of the way.
           return unless closing_ranges.all? { |range| range.source.match?(/\A[\s,]*\]\z/) }
 
-          corrector.replace(node.loc.selector, 'push')
+          replace_selector(corrector, node)
+
           node.arguments.zip(closing_ranges) do |argument, closing_range|
             corrector.remove(argument.loc.begin)
             corrector.remove(closing_range)
@@ -133,6 +134,17 @@ module RuboCop
 
           range_between(argument.children.last.source_range.end_pos, argument.loc.end.end_pos)
         end
+
+        def replace_selector(corrector, node)
+          if node.parenthesized? || node.single_line?
+            corrector.replace(node.loc.selector, 'push')
+          else
+            range = node.loc.selector.join(node.first_argument.source_range.begin)
+
+            corrector.replace(range, 'push(')
+            corrector.insert_after(node.last_argument.loc.end, ')')
+          end
+        end
       end
     end
   end

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

@@ -45,6 +45,8 @@ module RuboCop
         MSG_TRAILING_CONDITIONAL = 'Do not use trailing conditionals in string interpolation.'
         MSG_TERNARY = 'Do not return empty strings in string interpolation.'
 
+        INTERPOLATED_TYPES = %i[dstr dsym regexp xstr].freeze
+
         def on_interpolation(node)
           node.each_child_node(:if) do |child_node|
             if style == :trailing_conditional
@@ -63,28 +65,54 @@ module RuboCop
           return if child_node.modifier_form?
 
           if empty_if_outcome?(child_node)
-            ternary_style_autocorrect(child_node, child_node.else_branch.source, 'unless')
+            ternary_style_autocorrect(child_node, child_node.else_branch, 'unless')
           end
 
           return unless empty_else_outcome?(child_node)
 
-          ternary_style_autocorrect(child_node, child_node.if_branch.source, 'if')
+          ternary_style_autocorrect(child_node, child_node.if_branch, 'if')
         end
 
         def ternary_correction(node, child_node)
           return unless child_node.modifier_form?
 
-          ternary_component = if child_node.unless?
-                                "'' : #{child_node.if_branch.source}"
-                              else
-                                "#{child_node.if_branch.source} : ''"
-                              end
-
           add_offense(node, message: MSG_TRAILING_CONDITIONAL) do |corrector|
-            corrector.replace(node, "\#{#{child_node.condition.source} ? #{ternary_component}}")
+            next if nested_trailing_conditional?(child_node)
+
+            autocorrect_to_ternary(corrector, child_node)
+          end
+        end
+
+        def nested_trailing_conditional?(if_node)
+          if_node.each_descendant(:if).any? do |node|
+            node.modifier_form? && node.parent.parent&.type?(*INTERPOLATED_TYPES)
           end
         end
 
+        def autocorrect_to_ternary(corrector, if_node)
+          condition = if_node.condition.source
+          branch = ternary_branch_source(if_node.if_branch)
+          outcomes = if_node.unless? ? "'' : #{branch}" : "#{branch} : ''"
+
+          corrector.replace(if_node, "#{condition} ? #{outcomes}")
+        end
+
+        def ternary_branch_source(branch)
+          return branch.source unless command_call?(branch)
+
+          arguments = branch.first_argument.source_range.join(branch.last_argument.source_range)
+          method = branch.source_range.begin.join(arguments.begin).source.rstrip
+
+          "#{method}(#{arguments.source})"
+        end
+
+        def command_call?(node)
+          return false unless node.type?(:call, :super, :yield) && node.arguments?
+          return false if node.call_type? && (node.operator_method? || node.setter_method?)
+
+          !node.parenthesized?
+        end
+
         def empty_if_outcome?(node)
           empty_branch_outcome?(node.if_branch)
         end
@@ -99,9 +127,23 @@ module RuboCop
           branch.nil_type? || (branch.str_type? && branch.value.empty?)
         end
 
-        def ternary_style_autocorrect(node, outcome, condition)
+        def ternary_style_autocorrect(node, outcome, keyword)
           add_offense(node, message: MSG_TERNARY) do |corrector|
-            corrector.replace(node, "#{outcome} #{condition} #{node.condition.source}")
+            next if empty_string_conditional_in_condition?(node)
+
+            head = node.source_range.begin.join(outcome.source_range.begin)
+            tail = outcome.source_range.end.join(node.source_range.end)
+
+            corrector.remove(head)
+            corrector.replace(tail, " #{keyword} #{node.condition.source}")
+          end
+        end
+
+        def empty_string_conditional_in_condition?(if_node)
+          if_node.condition.each_descendant(:if).any? do |node|
+            next false if node.modifier_form? || !node.parent.parent&.type?(*INTERPOLATED_TYPES)
+
+            empty_if_outcome?(node) || empty_else_outcome?(node)
           end
         end
       end

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

@@ -147,8 +147,21 @@ module RuboCop
 
         # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in
         # an endless definition, so letting both correct in the same pass would double them.
+        # `Style/GuardClause` turns a single `if` body into several statements,
+        # which an endless definition cannot hold.
+        # `Style/RaiseArgs` would drop the parentheses of a `raise` that becomes
+        # the body in the same pass, which a method passed as an argument needs.
+        # `Style/IfUnlessModifier` and `Style/WhileUntilModifier` would turn the body into
+        # a modifier form, which then applies to the whole endless definition.
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+          [
+            Style::GuardClause,
+            Style::IfUnlessModifier,
+            Style::MethodCallWithArgsParentheses,
+            Style::MethodDefParentheses,
+            Style::RaiseArgs,
+            Style::WhileUntilModifier
+          ]
         end
 
         def on_def(node)
@@ -185,9 +198,7 @@ module RuboCop
             add_offense(node, message: MSG_MULTI_LINE) do |corrector|
               correct_to_multiline(corrector, node)
             end
-          elsif !node.endless? && can_be_made_endless?(node) && single_line_when_made_endless?(node)
-            return if too_long_when_made_endless?(node)
-
+          elsif convertible_to_endless?(node) && single_line_when_made_endless?(node)
             add_offense(node, message: MSG_REQUIRE_SINGLE) do |corrector|
               correct_to_endless(corrector, node)
             end
@@ -195,14 +206,18 @@ module RuboCop
         end
 
         def handle_require_always_style(node)
-          return if node.endless? || !can_be_made_endless?(node)
-          return if too_long_when_made_endless?(node)
+          return unless convertible_to_endless?(node)
 
           add_offense(node, message: MSG_REQUIRE_ALWAYS) do |corrector|
             correct_to_endless(corrector, node)
           end
         end
 
+        def convertible_to_endless?(node)
+          !node.endless? && can_be_made_endless?(node) &&
+            !too_long_when_made_endless?(node) && !ambiguous_when_made_endless?(node)
+        end
+
         def handle_disallow_style(node)
           return unless node.endless?
 
@@ -293,6 +308,23 @@ module RuboCop
           !endless_replacement(node).include?("\n")
         end
 
+        def ambiguous_when_made_endless?(node)
+          (operation = ambiguous_operation(node)) && ambiguous_enclosing_operation?(operation)
+        end
+
+        # @!method ambiguous_operation(node)
+        def_node_matcher :ambiguous_operation, <<~PATTERN
+          ^${
+            (if _ <any_def _>)
+            ({and or} any_def _)
+            ({while until} _ any_def)
+          }
+        PATTERN
+
+        def ambiguous_enclosing_operation?(operation)
+          operation.operator_keyword? || operation.modifier_form?
+        end
+
         def too_long_when_made_endless?(node)
           return false unless config.cop_enabled?('Layout/LineLength')