rubocop 1.87.0 → 1.88.0

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

@@ -38,10 +38,10 @@ module RuboCop
         GLOB_METHODS = %i[glob []].freeze
 
         def on_send(node)
-          return unless (receiver = node.receiver)
-          return unless receiver.receiver&.const_type? && receiver.receiver.short_name == :Dir
-          return unless GLOB_METHODS.include?(receiver.method_name)
-          return if multiple_argument?(receiver)
+          return unless dir_glob?(node.receiver)
+          # `sort` with a comparator block or block-pass changes the order, so it is
+          # not redundant with the default sorting performed by `Dir.glob`/`Dir[]`.
+          return if sort_with_comparator?(node) || multiple_argument?(node.receiver)
 
           selector = node.loc.selector
 
@@ -53,9 +53,20 @@ module RuboCop
 
         private
 
+        def dir_glob?(receiver)
+          return false unless receiver&.receiver&.const_type?
+          return false unless receiver.receiver.short_name == :Dir
+
+          GLOB_METHODS.include?(receiver.method_name)
+        end
+
         def multiple_argument?(glob_method)
           glob_method.arguments.count >= 2 || glob_method.first_argument&.splat_type?
         end
+
+        def sort_with_comparator?(node)
+          node.parent&.any_block_type? || node.last_argument&.block_pass_type?
+        end
       end
     end
   end

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

@@ -183,7 +183,7 @@ module RuboCop
         def_node_matcher :conversion_with_default?, <<~PATTERN
           {
             (or $(csend _ :to_h) (hash))
-            (or (block $(csend _ :to_h) ...) (hash))
+            (or (any_block $(csend _ :to_h) ...) (hash))
             (or $(csend _ :to_a) (array))
             (or $(csend _ :to_i) (int 0))
             (or $(csend _ :to_f) (float 0.0))
@@ -191,7 +191,6 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
           range = node.loc.dot
 
@@ -204,14 +203,10 @@ module RuboCop
             end
           end
 
-          unless assume_receiver_instance_exists?(node.receiver)
-            return if !guaranteed_instance?(node.receiver) && !check?(node)
-            return if respond_to_nil_method?(node)
-          end
+          return if guarded_by_nil_receiver?(node)
 
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
-        # rubocop:enable Metrics/AbcSize
 
         # rubocop:disable Metrics/AbcSize
         def on_or(node)
@@ -230,6 +225,18 @@ module RuboCop
 
         private
 
+        # Returns true when the `&.` is meaningful because the receiver may actually be nil.
+        def guarded_by_nil_receiver?(node)
+          return false if assume_receiver_instance_exists?(node.receiver)
+
+          guaranteed_instance = guaranteed_instance?(node.receiver)
+          return true if !guaranteed_instance && !check?(node)
+
+          # `nil.respond_to?(<nil method>)` is `true`, so `&.` is meaningful when the receiver
+          # may be nil. A guaranteed instance can never be nil, so `&.` is still redundant there.
+          respond_to_nil_method?(node) && !guaranteed_instance
+        end
+
         def assume_receiver_instance_exists?(receiver)
           return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
 

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

@@ -122,6 +122,10 @@ module RuboCop
 
               grandparent = node.parent.parent
               return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
+            # An empty array/percent literal (`*[]`, `*%w()`, ...) expands to nothing, so
+            # removing the splat would produce invalid or semantically different code.
+            elsif expanded_item.array_type? && expanded_item.children.empty?
+              return
             end
 
             yield

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

@@ -18,6 +18,7 @@ module RuboCop
       # * `to_sym` when called on a symbol literal or interpolated symbol.
       # * `to_i` when called on an integer literal or with `Integer()`.
       # * `to_f` when called on a float literal or with `Float()`.
+      # * `to_d` when called with `BigDecimal()`.
       # * `to_r` when called on a rational literal or with `Rational()`.
       # * `to_c` when called on a complex literal or with `Complex()`.
       # * `to_a` when called on an array literal, or with `Array.new`, `Array()` or `Array[]`.
@@ -63,6 +64,12 @@ module RuboCop
       #   # in this case, `Integer()` could return `nil`
       #   Integer(var, exception: false).to_i
       #
+      #   # bad
+      #   BigDecimal(var).to_d
+      #
+      #   # good
+      #   BigDecimal(var)
+      #
       #   # bad - chaining the same conversion
       #   foo.to_s.to_s
       #

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

@@ -62,7 +62,7 @@ module RuboCop
           {
             (block
               $(call _ {:each_with_index :with_index} ...)
-              (args (arg _)) ...)
+              {(args (arg _)) (args)} ...)
             (numblock
               $(call _ {:each_with_index :with_index} ...) 1 ...)
             (itblock

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # Checks for redundant `with_object`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because the return value changes:
+      #   `each_with_object` returns the memo object, while the corrected `each` returns
+      #   the receiver. This matters when the result of the expression is used.
+      #
       # @example
       #   # bad
       #   ary.each_with_object([]) do |v|

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

@@ -32,9 +32,12 @@ module RuboCop
       #   end
       #
       class RefinementImportMethods < Base
+        extend AutoCorrector
         extend TargetRubyVersion
 
         MSG = 'Use `import_methods` instead of `%<current>s` because it is deprecated in Ruby 3.1.'
+        MSG_REMOVED = 'Use `import_methods` instead of `%<current>s` ' \
+                      'because it was removed in Ruby 3.2.'
         RESTRICT_ON_SEND = %i[include prepend].freeze
 
         minimum_target_ruby_version 3.1
@@ -44,7 +47,11 @@ module RuboCop
           return unless (parent = node.parent)
           return unless parent.block_type? && parent.method?(:refine)
 
-          add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
+          template = target_ruby_version >= 3.2 ? MSG_REMOVED : MSG
+          message = format(template, current: node.method_name)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, 'import_methods')
+          end
         end
       end
     end

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

@@ -26,7 +26,15 @@ module RuboCop
           return if node.ancestors.none?(&:conditional?)
           return if part_of_ignored_node?(node)
 
-          add_offense(node) { |corrector| corrector.replace(node, "#{node.source} =~ $_") }
+          add_offense(node) do |corrector|
+            # `!` binds tighter than `=~`, so `!/foo/ =~ $_` would parse as
+            # `(!/foo/) =~ $_`. Wrap the match in parentheses to preserve the meaning.
+            if node.parent&.send_type? && node.parent.method?(:!)
+              corrector.replace(node.parent, "!(#{node.source} =~ $_)")
+            else
+              corrector.replace(node, "#{node.source} =~ $_")
+            end
+          end
 
           ignore_node(node)
         end

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

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for expressions where there is a call to a predicate
-      # method with at least one argument, where no parentheses are used around
-      # the parameter list, and a boolean operator, && or ||, is used in the
-      # last argument.
+      # Checks for method calls with at least one argument where no parentheses
+      # are used around the parameter list, and the call could be misread as an
+      # operand of a boolean operator (`&&` or `||`). Two forms are flagged:
+      #
+      # * a predicate method whose last argument is a `&&`/`||` expression, and
+      # * any method whose first argument is a ternary expression with a
+      #   `&&`/`||` condition.
       #
       # The idea behind warning for these constructs is that the user might
       # be under the impression that the return value from the method call is
@@ -23,6 +26,12 @@ module RuboCop
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end
+      #
+      #   # bad
+      #   foo a && b ? c : d
+      #
+      #   # good
+      #   foo(a && b ? c : d)
       class RequireParentheses < Base
         include RangeHelp
 

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

@@ -38,7 +38,8 @@ module RuboCop
       #   42)
       #
       class RequireRangeParentheses < Base
-        MSG = 'Wrap the endless range literal `%<range>s` to avoid precedence ambiguity.'
+        MSG = 'Wrap the range literal `%<range>s` in parentheses ' \
+              'to avoid confusion with an endless range.'
 
         def on_irange(node)
           return if node.parent&.begin_type?

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

@@ -40,11 +40,11 @@ module RuboCop
         def same_file?(file_path, required_feature)
           return false unless File.extname(file_path) == '.rb'
 
-          file_path == required_feature || remove_ext(file_path) == required_feature
-        end
-
-        def remove_ext(file_path)
-          File.basename(file_path, File.extname(file_path))
+          # `require_relative` is resolved relative to the current file's directory, so a
+          # bare `foo`/`foo.rb` (no path separator) requires the current file itself. Compare
+          # against the basename so this works whether `file_path` is relative or absolute.
+          basename = File.basename(file_path, '.rb')
+          required_feature == basename || required_feature == "#{basename}.rb"
         end
       end
     end

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

@@ -39,7 +39,7 @@ module RuboCop
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \
               '`TypeError` instead of catching the actual exception.'
-        INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
+        INVALID_TYPES = %i[array complex dstr false float hash nil int rational str sym true].freeze
 
         def on_resbody(node)
           invalid_exceptions = invalid_exceptions(node.exceptions)

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

@@ -34,6 +34,7 @@ module RuboCop
           {
             (send $(csend ...) $_ ...)
             (send $(any_block (csend ...) ...) $_ ...)
+            (send $(begin (csend ...)) $_ ...)
           }
         PATTERN
 

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

@@ -26,7 +26,7 @@ module RuboCop
 
         # @!method safe_navigation_empty_in_conditional?(node)
         def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
-          (if (csend (send ...) :empty?) ...)
+          (if (csend !csend :empty?) ...)
         PATTERN
 
         def on_if(node)

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

@@ -46,7 +46,7 @@ module RuboCop
           message = format_message_from(processed_source)
 
           add_offense(comment, message: message) do
-            autocorrect if autocorrect_requested?
+            autocorrect if autocorrect?
           end
         end
 
@@ -57,6 +57,10 @@ module RuboCop
         end
 
         def executable?(processed_source)
+          # Virtual sources (LSP buffers, programmatic `ProcessedSource`) have no file on
+          # disk to stat or `chmod`, so treat them as executable to skip the offense.
+          return true unless File.exist?(processed_source.file_path)
+
           # Returns true if stat is executable or if the operating system
           # doesn't distinguish executable files from nonexecutable files.
           # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362

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

@@ -90,12 +90,35 @@ module RuboCop
         def on_or_asgn(node)
           return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.lhs)
 
-          add_offense(node) if rhs_matches_lhs?(node.rhs, node.lhs)
+          add_offense(node) if or_and_asgn_self_assignment?(node.lhs, node.rhs)
         end
         alias on_and_asgn on_or_asgn
 
         private
 
+        def or_and_asgn_self_assignment?(lhs, rhs)
+          case lhs.type
+          when :casgn
+            rhs.const_type? && lhs.namespace == rhs.namespace && lhs.short_name == rhs.short_name
+          when :send, :csend
+            reader_self_assignment?(lhs, rhs)
+          else
+            rhs_matches_lhs?(rhs, lhs)
+          end
+        end
+
+        # Compares two reader calls (attribute `foo.bar` or key `hash['foo']`).
+        def reader_self_assignment?(lhs, rhs)
+          return false unless rhs.type == lhs.type
+          return false unless lhs.method?(rhs.method_name)
+          return false unless lhs.receiver == rhs.receiver
+          return false unless lhs.arguments == rhs.arguments
+
+          # `hash[foo] ||= hash[foo]` is intentionally allowed because a method-call key may
+          # return different results on each call.
+          lhs.arguments.none?(&:call_type?)
+        end
+
         def multiple_self_assignment?(node)
           lhs = node.lhs
           rhs = node.rhs

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

@@ -45,7 +45,7 @@ module RuboCop
         # @!method send_with_mixin_argument?(node)
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
-            (const _ _) {:#{SEND_METHODS.join(' :')}}
+            {nil? self (const _ _)} {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
               $(const _ _)+)
         PATTERN

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

@@ -75,6 +75,8 @@ module RuboCop
         end
 
         def same_conditions_node_different_branch?(variable, outer_local_variable)
+          return true if different_case_in_branch?(variable, outer_local_variable)
+
           variable_node = variable_node(variable)
           return false unless node_or_its_ascendant_conditional?(variable_node)
 
@@ -88,6 +90,18 @@ module RuboCop
             variable_node == outer_local_variable_node.else_branch
         end
 
+        # `case ... in` binds variables in the pattern itself, so a block argument in one
+        # `in` branch does not shadow a pattern variable from a different `in` branch of the
+        # same `case` (the branches are mutually exclusive).
+        def different_case_in_branch?(variable, outer_local_variable)
+          inner_branch = variable.scope.node.each_ancestor(:in_pattern).first
+          outer_branch = outer_local_variable.declaration_node.each_ancestor(:in_pattern).first
+
+          return false unless inner_branch && outer_branch
+
+          inner_branch != outer_branch && inner_branch.parent == outer_branch.parent
+        end
+
         def variable_node(variable)
           parent_node = variable.scope.node.parent
 

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

@@ -56,7 +56,9 @@ module RuboCop
               {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
               !#capacity_keyword_argument?
             ])
-            (send (const {nil? cbase} :Hash) :new hash #capacity_keyword_argument?)
+            (send (const {nil? cbase} :Hash) :new
+              {array hash (send (const {nil? cbase} {:Array :Hash}) :new)}
+              #capacity_keyword_argument?)
           }
         PATTERN
 

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

@@ -88,6 +88,10 @@ module RuboCop
             return unless (method = numeric_constructor_rescue_nil(node))
           end
 
+          # `Integer(arg, exception: false)` already suppresses the conversion error, so there
+          # is nothing unintentionally swallowed; adding another `exception: false` is wrong.
+          return if exception_keyword_argument?(method)
+
           arguments = method.arguments.map(&:source) << 'exception: false'
           prefer = "#{method.method_name}(#{arguments.join(', ')})"
           prefer = "#{method.receiver.source}#{method.loc.dot.source}#{prefer}" if method.receiver
@@ -100,6 +104,14 @@ module RuboCop
 
         private
 
+        def exception_keyword_argument?(method)
+          method.arguments.any? do |argument|
+            argument.hash_type? && argument.pairs.any? do |pair|
+              pair.key.sym_type? && pair.key.value == :exception
+            end
+          end
+        end
+
         def expected_exception_classes_only?(exception_classes)
           return true unless (arguments = exception_classes.first)
 

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

@@ -77,11 +77,28 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver
+          return unless (correction = symbol_conversion_correction(node.receiver))
 
-          if node.receiver.type?(:str, :sym)
-            register_offense(node, correction: node.receiver.value.to_sym.inspect)
-          elsif node.receiver.dstr_type?
-            register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")
+          register_offense(node, correction: correction)
+        end
+
+        def symbol_conversion_correction(receiver)
+          if receiver.type?(:str, :sym)
+            receiver.value.to_sym.inspect
+          elsif receiver.dstr_type? && !receiver.heredoc?
+            dstr_correction(receiver)
+          end
+        end
+
+        # Reuse the already-escaped inner source for a plain `"..."` string so embedded
+        # quotes stay escaped. Percent literals (`%{}`, `%Q{}`, ...) and adjacent string
+        # concatenation have multi-character or no delimiters, so slicing the source would
+        # corrupt them; fall back to the node's value there.
+        def dstr_correction(receiver)
+          if receiver.loc.begin&.source == '"'
+            ":\"#{receiver.source[1..-2]}\""
+          else
+            ":\"#{receiver.value.to_sym}\""
           end
         end
 

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

@@ -61,7 +61,7 @@ module RuboCop
         def arguments_match?(arguments, def_node)
           index = 0
 
-          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+          all_present = def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
             send_arg = arguments[index]
             case def_arg.type
             when :arg, :restarg, :optarg
@@ -70,6 +70,33 @@ module RuboCop
 
             send_arg && argument_match?(send_arg, def_arg)
           end
+
+          all_present && !extra_positional_arguments?(arguments, def_node)
+        end
+
+        # The enumerator re-invokes the method with these arguments, so passing more
+        # positional arguments than the method accepts raises `ArgumentError` at runtime.
+        def extra_positional_arguments?(arguments, def_node)
+          return false if variadic_parameters?(def_node) || expandable_arguments?(arguments)
+
+          positional_arguments(arguments).size > positional_parameters(def_node).size
+        end
+
+        def variadic_parameters?(def_node)
+          def_node.arguments.any? { |arg| arg.type?(:restarg, :forward_arg) }
+        end
+
+        # A splat or argument forwarding on the call side can expand to any arity.
+        def expandable_arguments?(arguments)
+          arguments.any? { |arg| arg.type?(:splat, :forwarded_args, :forwarded_restarg) }
+        end
+
+        def positional_arguments(arguments)
+          arguments.reject { |arg| arg.type?(:hash, :kwsplat, :block_pass, :forwarded_kwrestarg) }
+        end
+
+        def positional_parameters(def_node)
+          def_node.arguments.select { |arg| arg.type?(:arg, :optarg) }
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength

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

@@ -40,7 +40,7 @@ module RuboCop
         # top-level return node's ancestors should not be of block, def, or
         # defs type.
         def top_level_return?(return_node)
-          return_node.each_ancestor(:block, :any_def).none?
+          return_node.each_ancestor(:any_block, :any_def).none?
         end
       end
     end

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

@@ -35,7 +35,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
-          return unless node.attribute_accessor? && node.last_argument.def_type?
+          return unless node.attribute_accessor? && node.last_argument.any_def_type?
+          # A lone `def` argument (e.g. `attr_reader def foo; end`) has no preceding
+          # attribute, so there is no trailing comma to flag.
+          return unless node.arguments.size > 1
 
           trailing_comma = trailing_comma_range(node)
 

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

@@ -68,7 +68,9 @@ module RuboCop
 
           expr.text.scan(/(?<!\\)\]/) do
             pos = Regexp.last_match.begin(0)
-            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+            # If the unescaped bracket is the first character of the regexp, Ruby does not warn.
+            # `pos` is relative to the sub-expression, so add its start offset (`expr.ts`).
+            next if (expr.ts + pos).zero?
 
             location = range_at_index(node, expr.ts, pos)
 

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

@@ -67,11 +67,7 @@ module RuboCop
           range = offense_range(assignment)
 
           add_offense(range, message: message) do |corrector|
-            # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
-            # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
-            # the autocorrect will be skipped, even if the variable is unused.
-            next if sequential_assignment?(assignment_node) ||
-                    assignment_node.parent&.or_asgn_type?
+            next if uncorrectable_assignment?(assignment_node)
 
             autocorrect(corrector, assignment)
           end
@@ -79,6 +75,15 @@ module RuboCop
           ignore_node(assignment_node) if chained_assignment?(assignment_node)
         end
 
+        # Autocorrect is skipped when removing a variable would cause a syntax error
+        # (`x = 1, y = 2`), or where rewriting `x ||= 1`/`x &&= 1` to `x = 1` would raise
+        # `NameError` because the variable is not declared before the operator assignment.
+        def uncorrectable_assignment?(assignment_node)
+          sequential_assignment?(assignment_node) ||
+            assignment_node.parent&.or_asgn_type? ||
+            assignment_node.parent&.and_asgn_type?
+        end
+
         def ignored_assignment?(variable, assignment_node, assignment)
           assignment.used? || part_of_ignored_node?(assignment_node) ||
             variable_in_loop_condition?(assignment_node, variable)

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

@@ -107,11 +107,15 @@ module RuboCop
         end
 
         def find_method_definition(node, method_name)
-          node.each_ancestor.lazy.map do |ancestor|
-            ancestor.each_child_node(:def, :any_block).find do |child|
+          node.each_ancestor do |ancestor|
+            found = ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
-          end.find(&:itself)
+            return found if found
+            # A method defined in an outer lexical scope does not define this scope's method,
+            # so stop searching once a class/module boundary is crossed without a match.
+            return nil if ancestor.type?(:class, :module, :sclass)
+          end
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments

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

@@ -107,7 +107,10 @@ module RuboCop
           end
 
           def process_multiple_assignment(masgn_node)
-            masgn_node.assignments.each_with_index do |lhs_node, index|
+            # Iterate the top-level destructuring slots so each maps to the right-hand side
+            # element at the same position. Using the flattened `assignments` would misalign
+            # the index when a slot is itself a nested destructuring (e.g. `(a, b), c = x, y`).
+            masgn_node.lhs.children.each_with_index do |lhs_node, index|
               next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
               if masgn_node.rhs.array_type? && (rhs_node = masgn_node.rhs.children[index])

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

@@ -83,7 +83,7 @@ module RuboCop
 
         def autocorrect_block(corrector, node)
           block_arg = block_arg(node)
-          return if block_reassigns_arg?(node, block_arg)
+          return unless reducible_to_body?(node, block_arg)
 
           source = node.body.source
           source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
@@ -91,6 +91,27 @@ module RuboCop
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end
 
+        def reducible_to_body?(node, block_arg)
+          # A block with multiple arguments can't be reduced to its body (the extra arguments
+          # would become undefined references), and `next`/`break`/`redo` bound to the block
+          # become orphaned (a syntax error) once the block is removed.
+          return false if node.arguments.size > 1 || orphans_loop_control_keyword?(node)
+
+          # A lone non-simple argument (destructuring `|(a, b)|` or a splat `|*a|`) can't be
+          # substituted either, so reducing to the body would leave it referencing an
+          # undefined variable.
+          return false if node.arguments.one? && block_arg.nil?
+
+          !block_reassigns_arg?(node, block_arg)
+        end
+
+        def orphans_loop_control_keyword?(node)
+          node.body&.each_node(:next, :break, :redo)&.any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.type?(:any_block, :while, :until, :for) }
+          end
+        end
+
         def fix_indentation(source, range)
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")

data/lib/rubocop/cop/metrics/collection_literal_length.rb

@@ -75,7 +75,7 @@ module RuboCop
         private
 
         def collection_threshold
-          cop_config.fetch('LengthThreshold', Float::INFINITY)
+          cop_config.fetch('Max', Float::INFINITY)
         end
       end
     end

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

@@ -113,7 +113,7 @@ module RuboCop
               return :lexical
             when :def, :defs
               return :dynamic
-            when :block
+            when :block, :numblock, :itblock
               return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic