rubocop 1.53.0 → 1.90.0

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

@@ -6,15 +6,19 @@ 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.
       #
       #   # bad
       #   h = {a: 1, b: 2}
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = { a: 1, b: 2 }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
       #
       # @example EnforcedStyle: no_space
       #   # The `no_space` style enforces that hash literals have
@@ -22,9 +26,11 @@ module RuboCop
       #
       #   # bad
       #   h = { a: 1, b: 2 }
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
       #
       #   # good
       #   h = {a: 1, b: 2}
+      #   foo = {{a: 1} => {b: {c: 2}}}
       #
       # @example EnforcedStyle: compact
       #   # The `compact` style normally requires a space inside
@@ -83,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
 
@@ -116,7 +123,7 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? token1 : token2).pos
+          brace = (token1.left_brace? ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
           detected_style = expect_space ? 'no_space' : 'space'
 

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

@@ -168,7 +168,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          return true unless same_line?(token1, token2) && !token1.space_after?
+          !same_line?(token1, token2) || token1.space_after?
         end
       end
     end

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

@@ -22,11 +22,9 @@ module RuboCop
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
-        include RangeHelp
         extend AutoCorrector
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'
-        SPACE_MSG = 'Missing space inside string interpolation detected.'
+        MSG = '%<command>s space inside string interpolation.'
 
         def on_interpolation(begin_node)
           return if begin_node.multiline?
@@ -36,9 +34,9 @@ module RuboCop
           return if empty_brackets?(left, right, tokens: tokens)
 
           if style == :no_space
-            no_space_offenses(begin_node, left, right, NO_SPACE_MSG)
+            no_space_offenses(begin_node, left, right, MSG)
           else
-            space_offenses(begin_node, left, right, SPACE_MSG)
+            space_offenses(begin_node, left, right, MSG)
           end
         end
 

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

@@ -51,6 +51,7 @@ module RuboCop
           # there could be good reasons why it needs to end with a certain
           # number of newlines.
           return if ends_in_end?(processed_source)
+          return if end_with_percent_blank_string?(processed_source)
 
           whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
@@ -86,6 +87,10 @@ module RuboCop
           extra&.strip&.start_with?('__END__')
         end
 
+        def end_with_percent_blank_string?(processed_source)
+          processed_source.buffer.source.end_with?("%\n\n")
+        end
+
         def message(wanted_blank_lines, blank_lines)
           case blank_lines
           when -1

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

@@ -48,7 +48,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.lines.each_with_index do |line, index|
-            next unless line.end_with?(' ', "\t")
+            next unless line.match?(/[[:blank:]]\z/)
 
             process_line(line, index + 1)
           end
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def whitespace_is_indentation?(range, level)
-          range.source[/[ \t]+/].length <= level
+          range.source[/[[:blank:]]+/].length <= level
         end
 
         def whitespace_only?(range)
@@ -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
@@ -123,7 +123,9 @@ module RuboCop
         end
 
         def offense_range(lineno, line)
-          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+          source_range(
+            processed_source.buffer, lineno, (line.sub(/[[:blank:]]+\z/, '').length)...(line.length)
+          )
         end
       end
     end

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/legacy/corrector.rb

@@ -12,13 +12,23 @@ module RuboCop
           if corr.is_a?(CorrectionsProxy)
             merge!(corr.send(:corrector))
           else
-            # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
+            unless corr.empty?
+              warn Rainbow(<<~WARNING).yellow, uplevel: 1
+                `Corrector.new` with corrections is deprecated.
+                See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+              WARNING
+            end
+
             corr.each { |c| corrections << c }
           end
         end
 
         def corrections
-          # warn "#corrections is deprecated. Open an issue if you have a valid usecase." TODO
+          warn Rainbow(<<~WARNING).yellow, uplevel: 1
+            `Corrector#corrections` is deprecated. Open an issue if you have a valid usecase.
+            See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+          WARNING
+
           CorrectionsProxy.new(self)
         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,22 +6,37 @@ 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
       #
       #   # bad
       #   some_method a { |val| puts val }
       #
-      # @example
-      #
       #   # good
       #   # With parentheses, there's no ambiguity.
       #   some_method(a { |val| puts val })
       #   # 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 }
@@ -60,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?
@@ -76,10 +104,38 @@ 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.block_type? && !send_node.last_argument.send_node.arguments?
+          send_node.last_argument.any_block_type? && !send_node.last_argument.send_node.arguments?
         end
 
         def allowed_method_pattern?(node)
@@ -94,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.rb

@@ -14,8 +14,6 @@ module RuboCop
       #   # a `*` method invocation (i.e. `do_something.*(some_array)`).
       #   do_something *some_array
       #
-      # @example
-      #
       #   # good
       #
       #   # With parentheses, there's no ambiguity.

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
@@ -57,6 +60,7 @@ module RuboCop
       #   # good
       #   (a.foo)..(b.bar)
       class AmbiguousRange < Base
+        include RationalLiteral
         extend AutoCorrector
 
         MSG = 'Wrap complex range boundaries with parentheses to avoid ambiguity.'
@@ -79,9 +83,10 @@ module RuboCop
           yield range.end if range.end
         end
 
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable?(node)
           node.begin_type? ||
-            node.literal? ||
+            node.literal? || rational_literal?(node) ||
             node.variable? || node.const_type? || node.self_type? ||
             (node.call_type? && acceptable_call?(node))
         end
@@ -93,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
 

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

@@ -15,8 +15,6 @@ module RuboCop
       #   # (i.e. `do_something./(pattern)./(i)`)
       #   do_something /pattern/i
       #
-      # @example
-      #
       #   # good
       #
       #   # With parentheses, there's no ambiguity.