rubocop 1.84.2 → 1.86.2

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

@@ -128,12 +128,15 @@ module RuboCop
           if hash_pair_indented?(node, pair_ancestor, given_style)
             return check_hash_pair_indented_style(rhs, pair_ancestor)
           end
-
-          return false if !pair_ancestor && not_for_this_cop?(node)
+          return false if skip_for_context?(node, pair_ancestor)
 
           check_regular_indentation(node, lhs, rhs, given_style)
         end
 
+        def skip_for_context?(node, pair_ancestor)
+          pair_ancestor ? inside_multiline_chain_arg?(node) : not_for_this_cop?(node)
+        end
+
         def hash_pair_aligned?(pair_ancestor, given_style)
           pair_ancestor && given_style == :aligned
         end
@@ -152,7 +155,10 @@ module RuboCop
         end
 
         def check_hash_pair_indentation(node, lhs, rhs)
-          @base = find_hash_pair_alignment_base(node) || lhs.source_range
+          @base = find_hash_pair_alignment_base(node)
+          return false if !@base && inside_multiline_chain_arg?(node)
+
+          @base ||= first_dot_alignment_base(node, rhs) || lhs.source_range
           return if aligned_with_first_line_dot?(node, rhs)
 
           calculate_column_delta_offense(rhs, @base.column)
@@ -166,6 +172,50 @@ module RuboCop
           first_call.loc.dot.join(first_call.loc.selector)
         end
 
+        def first_dot_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.', '&.')
+
+          first_call = first_call_has_a_dot(node)
+          dot = first_call.loc.dot
+          return unless dot
+          return if first_call == node
+
+          after_block_base = after_multiline_block_base(first_call, node)
+          return after_block_base if after_block_base
+
+          return unless same_line?(dot, first_call.receiver.source_range)
+
+          dot.join(first_call.loc.selector)
+        end
+
+        def after_multiline_block_base(first_call, node)
+          return unless first_call.block_node&.multiline?
+
+          after_block = first_call.block_node.parent
+          return unless after_block&.call_type? && after_block.loc?(:dot) && after_block != node
+
+          after_block.loc.dot.join(after_block.loc.selector)
+        end
+
+        def inside_multiline_chain_arg?(node)
+          enclosing_call = find_enclosing_chain_call(node)
+          return false unless enclosing_call
+
+          !same_line?(enclosing_call.loc.selector, enclosing_call.receiver.source_range)
+        end
+
+        def find_enclosing_chain_call(node)
+          hash_ancestor = find_pair_ancestor(node).parent
+          enclosing_call = hash_ancestor.parent
+          return unless hash_arg_in_chain?(enclosing_call, hash_ancestor)
+
+          enclosing_call
+        end
+
+        def hash_arg_in_chain?(call, hash_node)
+          call&.call_type? && call.receiver != hash_node && call.loc?(:dot)
+        end
+
         def aligned_with_first_line_dot?(node, rhs)
           return false unless rhs.source.start_with?('.', '&.')
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the parameters on a multi-line method call or definition are aligned.
+      # Checks that the parameters on a multi-line method call or definition are aligned.
       #
       # To set the alignment of the first argument, use the
       # `Layout/FirstParameterIndentation` cop.

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

@@ -114,7 +114,7 @@ module RuboCop
 
         def other_cop_takes_precedence?(node)
           single_line_block_chain_enabled? && any_descendant?(node, :any_block) do |block_node|
-            block_node.parent.send_type? && block_node.parent.loc.dot && !block_node.multiline?
+            block_node.parent.send_type? && block_node.parent.loc.dot && block_node.single_line?
           end
         end
 

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

@@ -29,7 +29,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           arguments = node.arguments
 
           return unless node.arguments? && pipes?(arguments)

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

@@ -47,9 +47,11 @@ module RuboCop
           check(node, [:operator].freeze) if node.keyword?
         end
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node)
           check(node, %i[begin end].freeze)
         end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_break(node)
           check(node, [:keyword].freeze)

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

@@ -26,6 +26,7 @@ module RuboCop
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
+        RESTRICT_ON_SEND = %i[lambda].freeze
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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

@@ -6,8 +6,11 @@ module RuboCop
       # Checks for constant reassignments.
       #
       # Emulates Ruby's runtime warning "already initialized constant X"
-      # when a constant is reassigned in the same file and namespace using the
-      # `NAME = value` syntax.
+      # when a constant is reassigned in the same file and namespace.
+      #
+      # The cop tracks constants defined via `NAME = value` syntax as well as
+      # class/module keyword definitions. It detects reassignment when a constant
+      # is first defined one way and then redefined using the `NAME = value` syntax.
       #
       # The cop cannot catch all offenses, like, for example, when a constant
       # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
@@ -36,6 +39,14 @@ module RuboCop
       #     X = :bar
       #   end
       #
+      #   # bad
+      #   class FooError < StandardError; end
+      #   FooError = Class.new(RuntimeError)
+      #
+      #   # bad
+      #   module M; end
+      #   M = 1
+      #
       #   # good - keep only one assignment
       #   X = :bar
       #
@@ -69,16 +80,30 @@ module RuboCop
 
         # @!method remove_constant(node)
         def_node_matcher :remove_constant, <<~PATTERN
-          (send _ :remove_const
+          (send {nil? self} :remove_const
             ({sym str} $_))
         PATTERN
 
+        def on_class(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :class
+        end
+
+        def on_module(node)
+          return unless unconditional_definition?(node)
+
+          constant_definitions[definition_name(node)] ||= :module
+        end
+
         def on_casgn(node)
           return unless fixed_constant_path?(node)
           return unless simple_assignment?(node)
-          return if constant_names.add?(fully_qualified_constant_name(node))
 
-          add_offense(node, message: format(MSG, constant: node.name))
+          name = fully_qualified_constant_name(node)
+          return constant_definitions[name] = :casgn unless constant_definitions.key?(name)
+
+          add_offense(node, message: format(MSG, constant: constant_display_name(node)))
         end
 
         def on_send(node)
@@ -90,7 +115,7 @@ module RuboCop
 
           return if namespaces.none?
 
-          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+          constant_definitions.delete(fully_qualified_name_for(namespaces, constant))
         end
 
         private
@@ -104,7 +129,7 @@ module RuboCop
             return true if ancestor.type?(:module, :class)
 
             ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
-              freeze_method?(ancestor)
+              ancestor.type?(:masgn, :mlhs) || freeze_method?(ancestor)
           end
         end
 
@@ -128,6 +153,10 @@ module RuboCop
           ['', *namespaces, constant].join('::')
         end
 
+        def constant_display_name(node)
+          [*constant_namespaces(node), node.name].join('::')
+        end
+
         def constant_namespaces(node)
           node.each_path.select(&:const_type?).map(&:short_name)
         end
@@ -139,8 +168,29 @@ module RuboCop
             .reverse
         end
 
-        def constant_names
-          @constant_names ||= Set.new
+        def unconditional_definition?(node)
+          node.each_ancestor.all? do |ancestor|
+            ancestor.type?(:begin, :module, :class)
+          end
+        end
+
+        def definition_name(node)
+          identifier = node.identifier
+
+          if identifier.namespace&.cbase_type?
+            fully_qualified_name_for([], identifier.short_name)
+          else
+            namespaces = ancestor_namespaces(node) + identifier_namespaces(identifier)
+            fully_qualified_name_for(namespaces, identifier.short_name)
+          end
+        end
+
+        def identifier_namespaces(identifier)
+          identifier.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def constant_definitions
+          @constant_definitions ||= {}
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check that certain constants are fully qualified.
+      # Checks that certain constants are fully qualified.
       #
       # This is not enabled by default because it would mark a lot of offenses
       # unnecessarily.

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks unexpected overrides of the `Data` built-in methods
+      # via `Data.define`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Data.define(:members, :clone, :to_s)
+      #   b = Bad.new(members: [], clone: true, to_s: 'bad')
+      #   b.members #=> [] (overriding `Data#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.to_s #=> "bad" (overriding `Data#to_s`)
+      #
+      #   # good
+      #   Good = Data.define(:id, :name)
+      #   g = Good.new(id: 1, name: "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<data Good id=1, name="foo">
+      #
+      class DataDefineOverride < Base
+        MSG = '`%<member_name>s` member overrides `Data#%<method_name>s` and it may be unexpected.'
+        RESTRICT_ON_SEND = %i[define].freeze
+
+        # This is based on `Data.define.instance_methods.sort` in Ruby 4.0.0.
+        DATA_METHOD_NAMES = %i[
+          ! != !~ <=> == === __id__ __send__ class clone deconstruct deconstruct_keys
+          define_singleton_method display dup enum_for eql? equal? extend freeze frozen? hash
+          inspect instance_eval instance_exec instance_of? instance_variable_defined?
+          instance_variable_get instance_variable_set instance_variables is_a? itself kind_of?
+          members method methods nil? object_id private_methods protected_methods
+          public_method public_methods public_send remove_instance_variable respond_to? send
+          singleton_class singleton_method singleton_methods tap then to_enum to_h to_s with
+          yield_self
+        ].freeze
+        MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        # @!method data_define(node)
+        def_node_matcher :data_define, <<~PATTERN
+          (send
+            (const {nil? cbase} :Data) :define ...)
+        PATTERN
+
+        def on_send(node)
+          return unless data_define(node)
+
+          node.arguments.each do |arg|
+            next unless MEMBER_NAME_TYPES.include?(arg.type)
+
+            member_name = arg.value
+
+            next unless DATA_METHOD_NAMES.include?(member_name.to_sym)
+
+            message = format(MSG, member_name: member_name.inspect, method_name: member_name.to_s)
+            add_offense(arg, message: message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -197,6 +197,13 @@ module RuboCop
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
+        # @!method class_or_module_new_block?(node)
+        def_node_matcher :class_or_module_new_block?, <<~PATTERN
+          (block
+            (send (const _ {:Class :Module}) :new ...)
+            ...)
+        PATTERN
+
         def on_send(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           name, original_name = alias_method?(node)
 
@@ -233,9 +240,12 @@ module RuboCop
 
         def check_self_receiver(node, name)
           enclosing = node.parent_module_name
-          return unless enclosing
-
-          found_method(node, "#{enclosing}.#{name}")
+          if enclosing
+            found_method(node, "#{enclosing}.#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            scope = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            found_method(node, "#{scope}.#{name}", scope_id: anon_block_scope_id(anon_block))
+          end
         end
 
         def inside_condition?(node)
@@ -274,16 +284,50 @@ module RuboCop
         end
 
         def found_instance_method(node, name)
-          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
+          if (scope = node.parent_module_name)
+            found_method(node, "#{humanize_scope(scope)}#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            base = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            scope = node.each_ancestor(:sclass).any? ? "#<Class:#{base}>" : base
+            found_method(
+              node, "#{humanize_scope(scope)}#{name}", scope_id: anon_block_scope_id(anon_block)
+            )
+          else
+            found_sclass_method(node, name)
+          end
+        end
 
-          # Humanize the scope
+        def humanize_scope(scope)
           scope = scope.sub(
             /(?:(?<name>.*)::)#<Class:\k<name>>|#<Class:(?<name>.*)>(?:::)?/,
             '\k<name>.'
           )
-          scope << '#' unless scope.end_with?('.')
+          scope.end_with?('.') ? scope : "#{scope}#"
+        end
+
+        def anonymous_class_block(node)
+          first_block = node.each_ancestor(:block).first
+          return unless class_or_module_new_block?(first_block)
+          return if first_block.parent&.type?(:lvasgn)
+          return if node.each_ancestor(:sclass).any? { |s| !s.children.first.self_type? }
+
+          first_block
+        end
+
+        def anon_block_scope_id(anon_block)
+          parent = anon_block.parent
+          return unless parent&.type?(:any_block, :begin, :call, :casgn, :any_def)
+
+          if (receiver = named_receiver(parent))
+            "#{receiver.source}.#{parent.method_name}"
+          elsif !parent.begin_type? || parent.parent&.any_block_type?
+            source_location(anon_block)
+          end
+        end
 
-          found_method(node, "#{scope}#{name}")
+        def named_receiver(node)
+          receiver = node.receiver
+          receiver unless class_or_module_new_block?(receiver)
         end
 
         def found_sclass_method(node, name)
@@ -296,8 +340,10 @@ module RuboCop
           found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
         end
 
-        def found_method(node, method_name)
+        # rubocop:disable Metrics/AbcSize
+        def found_method(node, method_name, scope_id: nil)
           key = method_key(node, method_name)
+          key = "#{key}@#{scope_id}" if scope_id
           scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
@@ -314,6 +360,7 @@ module RuboCop
             @definitions[key] = node
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def method_key(node, method_name)
           if (ancestor_def = node.each_ancestor(:any_def).first)

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

@@ -63,7 +63,7 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return if node.body
           return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)

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

@@ -70,7 +70,7 @@ module RuboCop
 
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
-          return if cop_config['AllowComments'] && contains_comments?(node)
+          return if allow_comments?(node)
 
           range = offense_range(node)
 
@@ -83,6 +83,11 @@ module RuboCop
 
         private
 
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
+
         def offense_range(node)
           if node.loc.else
             node.source_range.begin.join(node.loc.else.begin)

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

@@ -53,11 +53,18 @@ module RuboCop
         def on_case_match(node)
           node.in_pattern_branches.each do |branch|
             next if branch.body
-            next if cop_config['AllowComments'] && contains_comments?(branch)
+            next if allow_comments?(branch)
 
             add_offense(branch)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

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

@@ -50,11 +50,18 @@ module RuboCop
         def on_case(node)
           node.when_branches.each do |when_node|
             next if when_node.body
-            next if cop_config['AllowComments'] && contains_comments?(when_node)
+            next if allow_comments?(when_node)
 
             add_offense(when_node)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

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

@@ -54,9 +54,14 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+          double_quoted_string = if node.source.include?('"')
+                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
+                                 else
+                                   node.source.gsub(/\A'|'\z/, '"')
+                                 end
 
-          parse(double_quoted_string).valid_syntax?
+          processed_source = parse(double_quoted_string)
+          processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
       end
     end

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

@@ -31,6 +31,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -39,6 +40,7 @@ module RuboCop
           {
             (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
             (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+            (itblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
           }
         PATTERN
 

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

@@ -65,7 +65,9 @@ module RuboCop
 
         maximum_target_ruby_version 2.7
 
-        def on_block(node)
+        # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
+        # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 

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

@@ -162,7 +162,7 @@ module RuboCop
         end
 
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true

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

@@ -63,19 +63,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized?
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)

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

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
-# cops need to be disabled so as to be able to provide a (bad) example of an
-# unneeded enable.
-
-# rubocop:disable Lint/RedundantCopEnableDirective
-# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -130,6 +124,3 @@ module RuboCop
     end
   end
 end
-
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -62,6 +62,22 @@ module RuboCop
       #   do_something if attrs.respond_to?(:[])
       #
       #   # bad
+      #   foo&.bar ? foo&.bar.baz : qux
+      #
+      #   # good
+      #   foo&.bar ? foo.bar.baz : qux
+      #
+      #   # bad
+      #   if foo&.bar
+      #     foo&.bar.baz
+      #   end
+      #
+      #   # good
+      #   if foo&.bar
+      #     foo.bar.baz
+      #   end
+      #
+      #   # bad
       #   while node&.is_a?(BeginNode)
       #     node = node.parent
       #   end
@@ -71,8 +87,9 @@ module RuboCop
       #     node = node.parent
       #   end
       #
-      #   # good - without `&.` this will always return `true`
+      #   # good - without `&.` this changes the return value for `nil`
       #   foo&.respond_to?(:to_a)
+      #   foo&.respond_to?(:class)
       #
       #   # bad - for `nil`s conversion methods return default values for the type
       #   foo&.to_h || {}
@@ -151,15 +168,15 @@ module RuboCop
         MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
                       'previous code/method invocations).'
 
-        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+        NIL_METHODS = nil.methods.to_set.freeze
 
         SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
 
         GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
 
-        # @!method respond_to_nil_specific_method?(node)
-        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
-          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        # @!method respond_to_nil_method?(node)
+        def_node_matcher :respond_to_nil_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_METHODS))
         PATTERN
 
         # @!method conversion_with_default?(node)
@@ -189,7 +206,7 @@ module RuboCop
 
           unless assume_receiver_instance_exists?(node.receiver)
             return if !guaranteed_instance?(node.receiver) && !check?(node)
-            return if respond_to_nil_specific_method?(node)
+            return if respond_to_nil_method?(node)
           end
 
           add_offense(range) { |corrector| corrector.replace(range, '.') }