rubocop 1.71.1 → 1.91.0

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -6,6 +6,8 @@ module RuboCop
       # Checks that brackets used for array literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Array pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: no_space (default)
       #   # The `no_space` style enforces that array literals have
       #   # no surrounding space.
@@ -82,22 +84,29 @@ module RuboCop
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
 
         def on_array(node)
-          return unless node.square_brackets?
+          return if node.array_type? && !node.square_brackets?
 
+          node = find_node_with_brackets(node)
           tokens, left, right = array_brackets(node)
+          return unless left && right
 
           if empty_brackets?(left, right, tokens: tokens)
             return empty_offenses(node, left, right, EMPTY_MSG)
           end
 
-          start_ok = next_to_newline?(node, left)
+          start_ok = next_to_newline?(tokens, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
 
-          issue_offenses(node, left, right, start_ok, end_ok)
+          issue_offenses(node, tokens, left, right, start_ok, end_ok)
         end
+        alias on_array_pattern on_array
 
         private
 
+        def find_node_with_brackets(node)
+          node.ancestors.find(&:const_pattern_type?) || node
+        end
+
         def autocorrect(corrector, node)
           tokens, left, right = array_brackets(node)
 
@@ -108,14 +117,14 @@ module RuboCop
           elsif style == :space
             SpaceCorrector.add_space(processed_source, corrector, left, right)
           else
-            compact_corrections(corrector, node, left, right)
+            compact_corrections(corrector, tokens, left, right)
           end
         end
 
         def array_brackets(node)
           tokens = processed_source.tokens_within(node)
 
-          left = tokens.find(&:left_array_bracket?)
+          left = tokens.find(&:left_bracket?)
           right = tokens.reverse_each.find(&:right_bracket?)
 
           [tokens, left, right]
@@ -125,8 +134,8 @@ module RuboCop
           cop_config['EnforcedStyleForEmptyBrackets']
         end
 
-        def next_to_newline?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
+        def next_to_newline?(tokens, token)
+          tokens[index_for(tokens, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -136,68 +145,65 @@ module RuboCop
           !/\S/.match?(processed_source.lines[line][0..col])
         end
 
-        def index_for(node, token)
-          processed_source.tokens_within(node).index(token)
+        def index_for(tokens, token)
+          tokens.index(token)
         end
 
         def line_and_column_for(token)
           [token.line - 1, token.column - 1]
         end
 
-        def issue_offenses(node, left, right, start_ok, end_ok)
+        # rubocop:disable-next Metrics/ParameterLists
+        def issue_offenses(node, tokens, left, right, start_ok, end_ok)
           case style
           when :no_space
-            start_ok = next_to_comment?(node, left)
+            start_ok = next_to_comment?(tokens, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           else
-            compact_offenses(node, left, right, start_ok, end_ok)
+            compact_offenses(node, tokens, left, right, start_ok, end_ok)
           end
         end
 
-        def next_to_comment?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
+        def next_to_comment?(tokens, token)
+          tokens[index_for(tokens, token) + 1].comment?
         end
 
-        def compact_offenses(node, left, right, start_ok, end_ok)
-          if qualifies_for_compact?(node, left, side: :left)
+        # rubocop:disable-next Metrics/ParameterLists
+        def compact_offenses(node, tokens, left, right, start_ok, end_ok)
+          if qualifies_for_compact?(tokens, left, side: :left)
             compact_offense(node, left, side: :left)
-          elsif !multi_dimensional_array?(node, left, side: :left)
+          elsif !multi_dimensional_array?(tokens, left, side: :left)
             space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
-          if qualifies_for_compact?(node, right)
+
+          if qualifies_for_compact?(tokens, right)
             compact_offense(node, right)
-          elsif !multi_dimensional_array?(node, right)
+          elsif !multi_dimensional_array?(tokens, right)
             space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
 
-        def qualifies_for_compact?(node, token, side: :right)
+        def qualifies_for_compact?(tokens, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) && token.space_before?
+            multi_dimensional_array?(tokens, token) && token.space_before?
           else
-            multi_dimensional_array?(node, token, side: :left) && token.space_after?
+            multi_dimensional_array?(tokens, token, side: :left) && token.space_after?
           end
         end
 
-        def multi_dimensional_array?(node, token, side: :right)
+        def multi_dimensional_array?(tokens, token, side: :right)
           offset = side == :right ? -1 : +1
-          i = index_for(node, token) + offset
-          i += offset while processed_source.tokens_within(node)[i].new_line?
+          i = index_for(tokens, token) + offset
+          i += offset while tokens[i].new_line?
           if side == :right
-            processed_source.tokens_within(node)[i].right_bracket?
+            tokens[i].right_bracket?
           else
-            processed_source.tokens_within(node)[i].left_array_bracket?
+            tokens[i].left_bracket?
           end
         end
 
-        def next_to_bracket?(token, side: :right)
-          line_index, col = line_and_column_for(token)
-          line = processed_source.lines[line_index]
-          side == :right ? line[col] == ']' : line[col + 2] == '['
-        end
-
         def compact_offense(node, token, side: :right)
           if side == :right
             space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
@@ -206,14 +212,14 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, node, left, right)
-          if multi_dimensional_array?(node, left, side: :left)
+        def compact_corrections(corrector, tokens, left, right)
+          if multi_dimensional_array?(tokens, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
 
-          if multi_dimensional_array?(node, right)
+          if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -103,6 +103,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -6,6 +6,8 @@ module RuboCop
       # Checks that braces used for hash literals have or don't have
       # surrounding space depending on configuration.
       #
+      # Hash pattern matching is handled in the same way.
+      #
       # @example EnforcedStyle: space (default)
       #   # The `space` style enforces that hash literals have
       #   # surrounding space.
@@ -87,6 +89,7 @@ module RuboCop
           check(tokens[-2], tokens[-1]) if tokens.size > 2
           check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
         end
+        alias on_hash_pattern on_hash
 
         private
 

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -113,7 +113,7 @@ module RuboCop
           return [] unless ast
 
           heredocs = []
-          ast.each_node(:str, :dstr, :xstr) do |node|
+          ast.each_node(:any_str) do |node|
             next unless node.heredoc?
 
             body = node.location.heredoc_body

data/lib/rubocop/cop/layout.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Layout` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Layout
+      extend LazyLoader
+
+      register_cop :AccessModifierIndentation, "#{__dir__}/layout/access_modifier_indentation"
+      register_cop :ArgumentAlignment, "#{__dir__}/layout/argument_alignment"
+      register_cop :ArrayAlignment, "#{__dir__}/layout/array_alignment"
+      register_cop :AssignmentIndentation, "#{__dir__}/layout/assignment_indentation"
+      register_cop :BeginEndAlignment, "#{__dir__}/layout/begin_end_alignment"
+      register_cop :BlockAlignment, "#{__dir__}/layout/block_alignment"
+      register_cop :BlockEndNewline, "#{__dir__}/layout/block_end_newline"
+      register_cop :CaseIndentation, "#{__dir__}/layout/case_indentation"
+      register_cop :ClassStructure, "#{__dir__}/layout/class_structure"
+      register_cop :ClosingHeredocIndentation, "#{__dir__}/layout/closing_heredoc_indentation"
+      register_cop :ClosingParenthesisIndentation, "#{__dir__}/layout/closing_parenthesis_indentation"
+      register_cop :CommentIndentation, "#{__dir__}/layout/comment_indentation"
+      register_cop :ConditionPosition, "#{__dir__}/layout/condition_position"
+      register_cop :DefEndAlignment, "#{__dir__}/layout/def_end_alignment"
+      register_cop :DotPosition, "#{__dir__}/layout/dot_position"
+      register_cop :ElseAlignment, "#{__dir__}/layout/else_alignment"
+      register_cop :EmptyComment, "#{__dir__}/layout/empty_comment"
+      register_cop :EmptyLineAfterGuardClause, "#{__dir__}/layout/empty_line_after_guard_clause"
+      register_cop :EmptyLineAfterMagicComment, "#{__dir__}/layout/empty_line_after_magic_comment"
+      register_cop :EmptyLineAfterMultilineCondition, "#{__dir__}/layout/empty_line_after_multiline_condition"
+      register_cop :EmptyLineBetweenDefs, "#{__dir__}/layout/empty_line_between_defs"
+      register_cop :EmptyLinesAfterModuleInclusion, "#{__dir__}/layout/empty_lines_after_module_inclusion"
+      register_cop :EmptyLinesAroundAccessModifier, "#{__dir__}/layout/empty_lines_around_access_modifier"
+      register_cop :EmptyLinesAroundArguments, "#{__dir__}/layout/empty_lines_around_arguments"
+      register_cop :EmptyLinesAroundAttributeAccessor, "#{__dir__}/layout/empty_lines_around_attribute_accessor"
+      register_cop :EmptyLinesAroundBeginBody, "#{__dir__}/layout/empty_lines_around_begin_body"
+      register_cop :EmptyLinesAroundBlockBody, "#{__dir__}/layout/empty_lines_around_block_body"
+      register_cop :EmptyLinesAroundClassBody, "#{__dir__}/layout/empty_lines_around_class_body"
+      register_cop :EmptyLinesAroundExceptionHandlingKeywords, "#{__dir__}/layout/empty_lines_around_exception_handling_keywords"
+      register_cop :EmptyLinesAroundMethodBody, "#{__dir__}/layout/empty_lines_around_method_body"
+      register_cop :EmptyLinesAroundModuleBody, "#{__dir__}/layout/empty_lines_around_module_body"
+      register_cop :EmptyLines, "#{__dir__}/layout/empty_lines"
+      register_cop :EndAlignment, "#{__dir__}/layout/end_alignment"
+      register_cop :EndOfLine, "#{__dir__}/layout/end_of_line"
+      register_cop :ExtraSpacing, "#{__dir__}/layout/extra_spacing"
+      register_cop :FirstArgumentIndentation, "#{__dir__}/layout/first_argument_indentation"
+      register_cop :FirstArrayElementIndentation, "#{__dir__}/layout/first_array_element_indentation"
+      register_cop :FirstArrayElementLineBreak, "#{__dir__}/layout/first_array_element_line_break"
+      register_cop :FirstHashElementIndentation, "#{__dir__}/layout/first_hash_element_indentation"
+      register_cop :FirstHashElementLineBreak, "#{__dir__}/layout/first_hash_element_line_break"
+      register_cop :FirstMethodArgumentLineBreak, "#{__dir__}/layout/first_method_argument_line_break"
+      register_cop :FirstMethodParameterLineBreak, "#{__dir__}/layout/first_method_parameter_line_break"
+      register_cop :FirstParameterIndentation, "#{__dir__}/layout/first_parameter_indentation"
+      register_cop :HashAlignment, "#{__dir__}/layout/hash_alignment"
+      register_cop :HeredocArgumentClosingParenthesis, "#{__dir__}/layout/heredoc_argument_closing_parenthesis"
+      register_cop :HeredocIndentation, "#{__dir__}/layout/heredoc_indentation"
+      register_cop :IndentationConsistency, "#{__dir__}/layout/indentation_consistency"
+      register_cop :IndentationStyle, "#{__dir__}/layout/indentation_style"
+      register_cop :IndentationWidth, "#{__dir__}/layout/indentation_width"
+      register_cop :InitialIndentation, "#{__dir__}/layout/initial_indentation"
+      register_cop :LeadingCommentSpace, "#{__dir__}/layout/leading_comment_space"
+      register_cop :LeadingEmptyLines, "#{__dir__}/layout/leading_empty_lines"
+      register_cop :LineContinuationLeadingSpace, "#{__dir__}/layout/line_continuation_leading_space"
+      register_cop :LineContinuationSpacing, "#{__dir__}/layout/line_continuation_spacing"
+      register_cop :LineEndStringConcatenationIndentation, "#{__dir__}/layout/line_end_string_concatenation_indentation"
+      register_cop :LineLength, "#{__dir__}/layout/line_length"
+      register_cop :MultilineArrayBraceLayout, "#{__dir__}/layout/multiline_array_brace_layout"
+      register_cop :MultilineArrayLineBreaks, "#{__dir__}/layout/multiline_array_line_breaks"
+      register_cop :MultilineAssignmentLayout, "#{__dir__}/layout/multiline_assignment_layout"
+      register_cop :MultilineBlockLayout, "#{__dir__}/layout/multiline_block_layout"
+      register_cop :MultilineHashBraceLayout, "#{__dir__}/layout/multiline_hash_brace_layout"
+      register_cop :MultilineHashKeyLineBreaks, "#{__dir__}/layout/multiline_hash_key_line_breaks"
+      register_cop :MultilineMethodArgumentLineBreaks, "#{__dir__}/layout/multiline_method_argument_line_breaks"
+      register_cop :MultilineMethodCallBraceLayout, "#{__dir__}/layout/multiline_method_call_brace_layout"
+      register_cop :MultilineMethodCallIndentation, "#{__dir__}/layout/multiline_method_call_indentation"
+      register_cop :MultilineMethodDefinitionBraceLayout, "#{__dir__}/layout/multiline_method_definition_brace_layout"
+      register_cop :MultilineMethodParameterLineBreaks, "#{__dir__}/layout/multiline_method_parameter_line_breaks"
+      register_cop :MultilineOperationIndentation, "#{__dir__}/layout/multiline_operation_indentation"
+      register_cop :ParameterAlignment, "#{__dir__}/layout/parameter_alignment"
+      register_cop :RedundantLineBreak, "#{__dir__}/layout/redundant_line_break"
+      register_cop :RescueEnsureAlignment, "#{__dir__}/layout/rescue_ensure_alignment"
+      register_cop :SingleLineBlockChain, "#{__dir__}/layout/single_line_block_chain"
+      register_cop :SpaceAfterColon, "#{__dir__}/layout/space_after_colon"
+      register_cop :SpaceAfterComma, "#{__dir__}/layout/space_after_comma"
+      register_cop :SpaceAfterMethodName, "#{__dir__}/layout/space_after_method_name"
+      register_cop :SpaceAfterNot, "#{__dir__}/layout/space_after_not"
+      register_cop :SpaceAfterSemicolon, "#{__dir__}/layout/space_after_semicolon"
+      register_cop :SpaceAroundBlockParameters, "#{__dir__}/layout/space_around_block_parameters"
+      register_cop :SpaceAroundEqualsInParameterDefault, "#{__dir__}/layout/space_around_equals_in_parameter_default"
+      register_cop :SpaceAroundKeyword, "#{__dir__}/layout/space_around_keyword"
+      register_cop :SpaceAroundMethodCallOperator, "#{__dir__}/layout/space_around_method_call_operator"
+      register_cop :SpaceAroundOperators, "#{__dir__}/layout/space_around_operators"
+      register_cop :SpaceBeforeBlockBraces, "#{__dir__}/layout/space_before_block_braces"
+      register_cop :SpaceBeforeBrackets, "#{__dir__}/layout/space_before_brackets"
+      register_cop :SpaceBeforeComma, "#{__dir__}/layout/space_before_comma"
+      register_cop :SpaceBeforeComment, "#{__dir__}/layout/space_before_comment"
+      register_cop :SpaceBeforeFirstArg, "#{__dir__}/layout/space_before_first_arg"
+      register_cop :SpaceBeforeSemicolon, "#{__dir__}/layout/space_before_semicolon"
+      register_cop :SpaceInLambdaLiteral, "#{__dir__}/layout/space_in_lambda_literal"
+      register_cop :SpaceInsideArrayPercentLiteral, "#{__dir__}/layout/space_inside_array_percent_literal"
+      register_cop :SpaceInsideArrayLiteralBrackets, "#{__dir__}/layout/space_inside_array_literal_brackets"
+      register_cop :SpaceInsideBlockBraces, "#{__dir__}/layout/space_inside_block_braces"
+      register_cop :SpaceInsideHashLiteralBraces, "#{__dir__}/layout/space_inside_hash_literal_braces"
+      register_cop :SpaceInsideParens, "#{__dir__}/layout/space_inside_parens"
+      register_cop :SpaceInsidePercentLiteralDelimiters, "#{__dir__}/layout/space_inside_percent_literal_delimiters"
+      register_cop :SpaceInsideRangeLiteral, "#{__dir__}/layout/space_inside_range_literal"
+      register_cop :SpaceInsideReferenceBrackets, "#{__dir__}/layout/space_inside_reference_brackets"
+      register_cop :SpaceInsideStringInterpolation, "#{__dir__}/layout/space_inside_string_interpolation"
+      register_cop :TrailingEmptyLines, "#{__dir__}/layout/trailing_empty_lines"
+      register_cop :TrailingWhitespace, "#{__dir__}/layout/trailing_whitespace"
+
+      autoload :EmptyLinesAroundBody, "#{__dir__}/mixin/empty_lines_around_body"
+    end
+  end
+end

data/lib/rubocop/cop/lazy_loader.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Extend a department module with this module and call `register_cop` to register
+    # the department's cops with the global registry without loading their files until
+    # a cop class itself is needed:
+    #
+    #   module RuboCop
+    #     module Cop
+    #       # The Foo department.
+    #       module Foo
+    #         extend LazyLoader
+    #
+    #         register_cop :BarBaz, "#{__dir__}/foo/bar_baz"
+    #       end
+    #     end
+    #   end
+    module LazyLoader
+      # Registers a cop for lazy loading. The cop appears in the registry by name right away,
+      # but its file is loaded only when the cop class is needed, e.g. when the cop is enabled
+      # for an inspection run.
+      #
+      # The path must be absolute so that loading does not depend on `$LOAD_PATH` and cannot resolve
+      # to another RuboCop installation.
+      #
+      # @param constant_name [Symbol] name of the cop class, e.g. `:BarBaz`
+      # @param path [String] absolute path to the file defining the cop class,
+      #   with or without the `.rb` extension
+      def register_cop(constant_name, path)
+        raise ArgumentError, "cop path must be absolute: #{path}" unless File.absolute_path?(path)
+
+        autoload constant_name, path
+
+        qualified_name = "#{name}::#{constant_name}"
+
+        Registry.global.lazy_load(Badge.for(qualified_name), qualified_name)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/ambiguous_assignment.rb

@@ -19,35 +19,27 @@ module RuboCop
       #   x != y # or x = !y
       #
       class AmbiguousAssignment < Base
+        include CheckAssignment
         include RangeHelp
 
         MSG = 'Suspicious assignment detected. Did you mean `%<op>s`?'
 
-        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
-
         MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
-        def on_asgn(node)
-          return unless (rhs = rhs(node))
+        alias on_csend on_send
+
+        private
 
-          range = range_between(node.loc.operator.end_pos - 1, rhs.source_range.begin_pos + 1)
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless (operator = node.loc.operator)
+
+          range = range_between(operator.end_pos - 1, rhs.source_range.begin_pos + 1)
           source = range.source
           return unless MISTAKES.key?(source)
 
           add_offense(range, message: format(MSG, op: MISTAKES[source]))
         end
-
-        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
-
-        private
-
-        def rhs(node)
-          if node.casgn_type?
-            node.children[2]
-          else
-            node.children[1]
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -6,8 +6,13 @@ module RuboCop
       # Checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop also detects `do...end` blocks that are likely intended for
+      # an enumerable method in the arguments but actually bind to the outer
+      # method call. For example, in `render json: data.map do |x| x end`,
+      # Ruby parses the `do...end` block as belonging to `render`, not `map`.
+      #
       # This cop can customize allowed methods with `AllowedMethods`.
-      # By default, there are no methods to allowed.
+      # By default, there are no allowed methods.
       #
       # @example
       #
@@ -20,6 +25,18 @@ module RuboCop
       #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
+      #   # bad
+      #   render json: data.map do |item|
+      #     item.to_h
+      #   end
+      #
+      #   # good
+      #   render json: data.map { |item| item.to_h }
+      #
+      #   # good
+      #   mapped = data.map { |item| item.to_h }
+      #   render json: mapped
+      #
       #   # good
       #   # Operator methods require no disambiguation
       #   foo == bar { |b| b.baz }
@@ -58,6 +75,19 @@ module RuboCop
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
+        MSG_DO_END_BLOCK = '`%<inner_method>s` is called without a block because the ' \
+                           '`do` block binds to `%<outer_method>s`. ' \
+                           'Use braces or extract to a variable.'
+
+        BLOCK_METHODS = %i[
+          map collect flat_map collect_concat
+          select filter find_all reject
+          find detect
+          each each_with_object each_with_index
+          reduce inject
+          sort_by min_by max_by
+          group_by filter_map
+        ].to_set.freeze
 
         def on_send(node)
           return unless node.arguments?
@@ -74,8 +104,36 @@ module RuboCop
         end
         alias on_csend on_send
 
+        def on_block(node)
+          return if node.braces?
+
+          send_node = node.send_node
+          block_method_arg = find_ambiguous_block_method(node)
+          return unless block_method_arg
+
+          add_offense(block_method_arg,
+                      message: format(MSG_DO_END_BLOCK,
+                                      inner_method: block_method_arg.method_name,
+                                      outer_method: send_node.method_name))
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
         private
 
+        def find_ambiguous_block_method(block_node)
+          send_node = block_node.send_node
+          return unless send_node.send_type? && send_node.arguments?
+          return if send_node.parenthesized?
+
+          block_method_arg = find_block_method_arg(send_node)
+          return unless block_method_arg
+          return if allowed_method?(block_method_arg.method_name) ||
+                    matches_allowed_pattern?(block_method_arg.source)
+
+          block_method_arg
+        end
+
         def ambiguous_block_association?(send_node)
           send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
         end
@@ -92,6 +150,19 @@ module RuboCop
           format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
 
+        # Only the call the `do` block could actually have attached to is a candidate:
+        # the one whose source ends where the arguments end. This skips calls chained
+        # into another call (`foo bar.map.to_a`) and calls buried inside a
+        # parenthesized subcall (`foo bar(baz.map)`), which were never block candidates.
+        def find_block_method_arg(send_node)
+          end_pos = send_node.source_range.end_pos
+
+          send_node.last_argument.each_node(:call).find do |node|
+            node.source_range.end_pos == end_pos &&
+              BLOCK_METHODS.include?(node.method_name) && !node.arguments?
+          end
+        end
+
         def wrap_in_parentheses(corrector, node)
           range = node.loc.selector.end.join(node.first_argument.source_range.begin)
 

data/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb

@@ -44,13 +44,6 @@ module RuboCop
         RESTRICT_ON_SEND = PRECEDENCE.flatten.freeze
         MSG = 'Wrap expressions with varying precedence with parentheses to avoid ambiguity.'
 
-        def on_new_investigation
-          # Cache the precedence of each node being investigated
-          # so that we only need to calculate it once
-          @node_precedences = {}
-          super
-        end
-
         def on_and(node)
           return unless (parent = node.parent)
 
@@ -77,9 +70,7 @@ module RuboCop
         private
 
         def precedence(node)
-          @node_precedences.fetch(node) do
-            PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
-          end
+          PRECEDENCE.index { |operators| operators.include?(operator_name(node)) }
         end
 
         def operator?(node)

data/lib/rubocop/cop/lint/ambiguous_range.rb

@@ -27,7 +27,9 @@ module RuboCop
       # @example
       #   # bad
       #   x || 1..2
+      #   x - 1..2
       #   (x || 1..2)
+      #   x || 1..y || 2
       #   1..2.to_a
       #
       #   # good, unambiguous
@@ -41,6 +43,7 @@ module RuboCop
       #
       #   # good, ambiguity removed
       #   x || (1..2)
+      #   (x - 1)..2
       #   (x || 1)..2
       #   (x || 1)..(y || 2)
       #   (1..2).to_a
@@ -80,14 +83,13 @@ module RuboCop
           yield range.end if range.end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
             node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def acceptable_call?(node)
           return true if node.unary_operation?
@@ -96,6 +98,8 @@ module RuboCop
           # to avoid the ambiguity of `1..2.to_a`.
           return false if node.receiver&.basic_literal?
 
+          return false if node.operator_method? && !node.method?(:[])
+
           require_parentheses_for_method_chain? || node.receiver.nil?
         end