rubocop 1.84.2 → 1.88.1

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/assignment_in_condition.rb

@@ -78,13 +78,25 @@ module RuboCop
         end
 
         def allowed_construct?(asgn_node)
-          asgn_node.begin_type? || conditional_assignment?(asgn_node)
+          return true if asgn_node.begin_type?
+
+          conditional_assignment?(asgn_node) || discarded_assignment?(asgn_node)
         end
 
         def conditional_assignment?(asgn_node)
           !asgn_node.loc.operator
         end
 
+        # An assignment that is a statement of a multi-statement `begin`
+        # (e.g. `(foo = bar; baz)`) has its value discarded, so it is not used
+        # as the condition. Wrapping it in parentheses would only conflict with
+        # `Style/RedundantParentheses`, so it is left alone.
+        def discarded_assignment?(asgn_node)
+          parent = asgn_node.parent
+
+          parent&.begin_type? && parent.children.size > 1
+        end
+
         def skip_children?(asgn_node)
           (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||

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

@@ -80,7 +80,6 @@ module RuboCop
           check_assignment_chain(arg_name, arg_value)
         end
 
-        # rubocop:disable Metrics/AbcSize
         def check_assignment_chain(arg_name, node)
           return unless node.lvasgn_type?
 
@@ -88,7 +87,7 @@ module RuboCop
           current_node = node
 
           while current_node.lvasgn_type?
-            seen_variables << current_node.children.first if current_node.lvasgn_type?
+            seen_variables << current_node.children.first
             current_node = current_node.children.last
           end
 
@@ -99,7 +98,6 @@ module RuboCop
 
           add_offense(current_node, message: format(MSG, arg_name: arg_name))
         end
-        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
+      # Checks for overwriting an exception with an exception result by using ``rescue =>``.
       #
       # You intended to write as `rescue StandardError`.
       # However, you have written `rescue => StandardError`.

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

@@ -6,11 +6,19 @@ 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 cannot catch all offenses, like, for example, when a constant
-      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      # 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 using metaprogramming
+      # (`Module#const_set`).
+      #
+      # By default the cop also cannot detect reassignment across files.
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed,
+      # the cop additionally consults the project-wide index and reports reassignments
+      # whose previous definition lives in another file.
       #
       # The cop only takes into account constants assigned in a "simple" way: directly
       # inside class/module definition, or within another constant. Other type of assignments
@@ -36,6 +44,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
       #
@@ -63,22 +79,44 @@ module RuboCop
       #   end
       #
       class ConstantReassignment < Base
+        include ProjectIndexHelp
+
         MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+        CROSS_FILE_MSG = 'Constant `%<constant>s` is already assigned in `%<path>s`.'
 
         RESTRICT_ON_SEND = %i[remove_const].freeze
 
         # @!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)
+
+          if constant_definitions.key?(name)
+            add_offense(node, message: format(MSG, constant: constant_display_name(node)))
+            return
+          end
+
+          constant_definitions[name] = :casgn
+          report_cross_file_collision(node, name, constant_display_name(node))
         end
 
         def on_send(node)
@@ -90,7 +128,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 +142,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 +166,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 +181,48 @@ 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
+
+        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))
+
+          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

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.
@@ -13,12 +13,12 @@ module RuboCop
       #
       # Large projects will over time end up with one or two constant names that
       # are problematic because of a conflict with a library or just internally
-      # using the same name a namespace and a class. To avoid too many unnecessary
-      # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
+      # using the same name for a namespace and a class. To avoid too many unnecessary
+      # offenses, enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
-      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
-      # conflicting rules. Because it respects user configurations that want to enable
-      # this cop which is disabled by default.
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled,
+      # to prevent conflicting rules. This is because it respects user configurations
+      # that want to enable this cop which is disabled by default.
       #
       # @example
       #   # By default checks every constant

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/debugger.rb

@@ -73,7 +73,6 @@ module RuboCop
       #   require 'my_debugger/start'
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
-        BLOCK_TYPES = %i[block numblock itblock kwbegin].freeze
 
         def on_send(node)
           return if assumed_usage_context?(node)

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

@@ -14,7 +14,7 @@ module RuboCop
       #       Alternative: 'alternative_value'
       #       DeprecatedVersion: 'deprecated_version'
       #
-      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException, `Random::DEFAULT`,
+      # By default, `NIL`, `TRUE`, `FALSE`, `Net::HTTPServerException`, `Random::DEFAULT`,
       # `Struct::Group`, and `Struct::Passwd` are configured.
       #
       # @example
@@ -49,7 +49,7 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? constant_name(node, node.short_name) : node.source
+          constant = node.source.delete_prefix('::')
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -63,12 +63,6 @@ module RuboCop
 
         private
 
-        def constant_name(node, nested_constant_name)
-          return nested_constant_name.to_s unless node.namespace.const_type?
-
-          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
-        end
-
         def message(good, bad, deprecated_version)
           deprecated_message = ", deprecated since Ruby #{deprecated_version}" if deprecated_version
 

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)
@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.source)
+          !line_comment || !comment_disables_cop?(line_comment)
         end
 
         def allow_empty_lambdas?
@@ -85,8 +85,8 @@ module RuboCop
         end
 
         def comment_disables_cop?(comment)
-          regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
-          Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.disabled? && directive.cop_names.include?(cop_name)
         end
       end
     end

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/ensure_return.rb

@@ -43,7 +43,25 @@ module RuboCop
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
-          node.branch&.each_node(:return) { |return_node| add_offense(return_node) }
+          node.branch&.each_node(:return) do |return_node|
+            next if return_from_inner_scope?(return_node, node)
+
+            add_offense(return_node)
+          end
+        end
+
+        private
+
+        # A `return` inside a nested method definition or lambda within the
+        # `ensure` returns from that inner scope, not from the method whose
+        # `ensure` this is, so it is not an offense. A `return` inside a plain
+        # block (or `proc`) does propagate out, so it remains an offense.
+        def return_from_inner_scope?(return_node, ensure_node)
+          return_node.each_ancestor do |ancestor|
+            break if ancestor == ensure_node
+            return true if ancestor.any_def_type? || (ancestor.any_block_type? && ancestor.lambda?)
+          end
+          false
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
       # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
       # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
       # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
-      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      # be replaced by `ERB.new(str, trim_mode: trim_mode, eoutvar: eoutvar)`.
       #
       # @example
       #   # Target codes supports Ruby 2.6 and higher only
@@ -148,7 +148,9 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
+          if arguments[2] && !arguments[2].hash_type?
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
+          end
 
           if arguments[3] && !arguments[3].hash_type?
             overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"

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

@@ -104,6 +104,7 @@ module RuboCop
 
         def literal_safe?(node)
           return false unless node
+          return literal_safe?(node.children.first) if node.begin_type?
 
           (node.numeric_type? && node.value.zero?) || node.nil_type?
         end

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

@@ -61,11 +61,15 @@ module RuboCop
         private
 
         def scheduler_compatible?(io1, io2)
-          return false unless io1&.array_type? && io1.values.size == 1
+          return false unless single_io_array?(io1)
 
           io2&.array_type? ? io2.values.empty? : (io2.nil? || io2.nil_type?)
         end
 
+        def single_io_array?(node)
+          node&.array_type? && node.values.size == 1 && !node.values.first.splat_type?
+        end
+
         def preferred_method(read, write, timeout)
           timeout_argument = timeout.nil? ? '' : "(#{timeout.source})"