rubocop 1.88.1 → 1.89.0

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

@@ -73,7 +73,12 @@ module RuboCop
         end
 
         def find_pair_ancestor(node)
-          node.each_ancestor.find(&:pair_type?)
+          node.each_ancestor do |ancestor|
+            return ancestor if ancestor.pair_type?
+            break if grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+          end
+
+          nil
         end
 
         def unwrap_block_node(node)
@@ -405,7 +410,7 @@ module RuboCop
 
         def find_continuation_node(node)
           receiver = node.receiver
-          return receiver.send_node if single_line_block_receiver?(receiver)
+          return leftmost_call_on_same_line(receiver) if single_line_block_receiver?(receiver)
           return unless receiver.call_type? && receiver.loc.dot
           return receiver if receiver.receiver.begin_type? && node.block_node.single_line?
           return unless receiver.loc.dot.line > receiver.receiver.last_line
@@ -417,9 +422,19 @@ module RuboCop
           receiver.single_line? && receiver.any_block_type?
         end
 
+        def leftmost_call_on_same_line(node)
+          current = node.any_block_type? ? node.send_node : node
+          while current.receiver&.call_type? &&
+                current.receiver.loc?(:dot) &&
+                current.receiver.loc.dot.line == current.loc.dot.line
+            current = current.receiver
+          end
+          current
+        end
+
         def handle_descendant_block(node)
           receiver = node.receiver
-          return receiver.send_node if single_line_block_receiver?(receiver)
+          return leftmost_call_on_same_line(receiver) if single_line_block_receiver?(receiver)
 
           block_node = node.each_descendant(:any_block).first
           return unless block_node&.multiline?

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

@@ -49,6 +49,7 @@ module RuboCop
       class RedundantLineBreak < Base
         include CheckAssignment
         include CheckSingleLineSuitability
+        include ReparsedEquivalence
         extend AutoCorrector
 
         MSG = 'Redundant line break detected.'
@@ -82,12 +83,88 @@ module RuboCop
         end
 
         def register_offense(node)
+          # The exact single-line correction is verified to parse equivalently
+          # before the offense is registered, so a join that would change how
+          # the code parses is never reported or offered.
+          return if verified_by_reparse([node], oversized: :verify).empty?
+
           add_offense(node) do |corrector|
             corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
         end
 
+        def apply_reparse_correction(corrector, node)
+          corrector.replace(node, to_single_line(node.source).strip)
+        end
+
+        # Joining lines shifts the value of any later `__LINE__`, exactly as
+        # any other line-removing correction does; neutralize it on both sides
+        # with an identifier, which stays valid in every position the keyword
+        # can appear in.
+        def preprocess_reparsed_source(source)
+          source.gsub(/\b__LINE__\b/, '__LINE0__')
+        end
+
+        def normalize_reparsed_ast(node)
+          fold_string_concatenation(node)
+        end
+
+        # Joining lines merges split string literals (`"a" \<newline> "b"` into
+        # `"ab"`) and turns mixed-quote pairs into `+` concatenation, which
+        # changes the tree but not the resulting string. Normalize all string
+        # concatenation to a canonical form before comparing: nested
+        # concatenations are flattened and adjacent literal parts merged.
+        def fold_string_concatenation(node)
+          return node unless node.is_a?(::Parser::AST::Node)
+
+          children = node.children.map { |child| fold_string_concatenation(child) }
+          node = node.updated(nil, children)
+
+          parts = string_concatenation_parts(node)
+          return node unless parts
+
+          merged = merge_string_parts(parts)
+          if merged.one? && merged.first.str_type?
+            node.updated(:str, merged.first.children)
+          else
+            node.updated(:dstr, merged)
+          end
+        end
+
+        def string_concatenation_parts(node)
+          case node.type
+          when :dstr
+            node.children
+          when :send
+            parts = [node.receiver, *node.arguments]
+            parts if node.method?(:+) && parts.all? { |part| stringish?(part) }
+          end
+        end
+
+        def merge_string_parts(parts)
+          flattened = parts.flat_map do |part|
+            part.is_a?(::Parser::AST::Node) && part.dstr_type? ? part.children : [part]
+          end
+
+          flattened.chunk_while { |left, right| plain_string?(left) && plain_string?(right) }
+                   .map { |chunk| merge_plain_strings(chunk) }
+        end
+
+        def merge_plain_strings(chunk)
+          return chunk.first if chunk.one?
+
+          chunk.first.updated(:str, [chunk.map { |part| part.children.first }.join])
+        end
+
+        def stringish?(node)
+          node.is_a?(::Parser::AST::Node) && %i[str dstr].include?(node.type)
+        end
+
+        def plain_string?(node)
+          node.is_a?(::Parser::AST::Node) && node.str_type? && node.children.one?
+        end
+
         def offense?(node)
           return false unless node.multiline? && suitable_as_single_line?(node)
           return require_backslash?(node) if node.operator_keyword?

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

@@ -94,10 +94,10 @@ module RuboCop
             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
 
@@ -117,7 +117,7 @@ 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
 
@@ -134,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)
@@ -145,68 +145,67 @@ 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 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
+        # rubocop:enable Metrics/ParameterLists
 
-        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 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
+        # rubocop:enable Metrics/ParameterLists
 
-        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_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)
@@ -215,14 +214,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.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,25 +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 = node.expression)
+        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 }
       end
     end
   end

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

@@ -6,6 +6,11 @@ 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 allowed methods.
       #
@@ -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/constant_reassignment.rb

@@ -209,21 +209,12 @@ module RuboCop
         def report_cross_file_collision(node, fully_qualified_name, display_name)
           return unless project_index
           return unless (declaration = project_index[fully_qualified_name.delete_prefix('::')])
-          return unless (prior = prior_definition_in_other_file(declaration))
+          return unless (prior = prior_definition_in_other_file(declaration.definitions))
 
           msg = format(CROSS_FILE_MSG, constant: display_name, path: prior.location.to_file_path)
 
           add_offense(node, message: msg)
         end
-
-        def prior_definition_in_other_file(declaration)
-          current = processed_source.file_path
-
-          declaration.definitions.find do |definition|
-            other = definition.location.to_file_path
-            !File.identical?(other, current)
-          end
-        end
       end
     end
   end

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

@@ -20,6 +20,12 @@ module RuboCop
       # to prevent conflicting rules. This is because it respects user configurations
       # that want to enable this cop which is disabled by default.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, only genuinely ambiguous constants are reported: those
+      # that resolve to a different declaration through the surrounding
+      # nesting than they would fully qualified. This makes the cop practical
+      # to enable without `Only`/`Ignore` lists.
+      #
       # @example
       #   # By default checks every constant
       #
@@ -60,6 +66,8 @@ module RuboCop
       #   Login
       #
       class ConstantResolution < Base
+        include ProjectIndexHelp
+
         MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
 
         # @!method unqualified_const?(node)
@@ -69,12 +77,29 @@ module RuboCop
 
         def on_const(node)
           return if !unqualified_const?(node) || node.parent&.defined_module || node.loc.nil?
+          return if project_index && !ambiguous_resolution?(node)
 
           add_offense(node)
         end
 
         private
 
+        # When `AllCops/UseProjectIndex` is enabled, only genuinely ambiguous
+        # references are reported: the constant resolves to a different
+        # declaration through the lexical nesting than it would fully
+        # qualified. Names that resolve identically either way, or that the
+        # index cannot resolve at all (e.g. constants from gems), are not
+        # reported.
+        def ambiguous_resolution?(node)
+          name = node.short_name.to_s
+          relative = project_index.resolve_constant(name, lexical_nesting_of(node))
+          absolute = project_index.resolve_constant(name, [])
+
+          !relative.nil? && !absolute.nil? && relative.name != absolute.name
+        rescue StandardError
+          false
+        end
+
         def const_name?(name)
           name = name.to_s
           (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)