rubocop 1.85.1 → 1.86.1

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_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/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/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

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

@@ -37,20 +37,25 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_send(node)
           return unless require_safe_navigation?(node)
 
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
+            return if ternary_safe_navigation?(node, safe_nav)
 
             begin_range = node.loc.dot || safe_nav.source_range.end
             location = begin_range.join(node.source_range.end)
 
             add_offense(location) do |corrector|
+              next if ternary_else_branch?(node, safe_nav)
+
               autocorrect(corrector, offense_range: location, send_node: node)
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
@@ -61,6 +66,18 @@ module RuboCop
           parent.rhs != node || parent.lhs.receiver != parent.rhs.receiver
         end
 
+        def ternary_safe_navigation?(node, safe_nav)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && node.equal?(parent.if_branch) && parent.condition == safe_nav
+        end
+
+        def ternary_else_branch?(node, safe_nav)
+          return false unless (parent = node.parent)
+
+          parent.if_type? && node.equal?(parent.else_branch) && parent.condition == safe_nav
+        end
+
         # @param [Parser::Source::Range] offense_range
         # @param [RuboCop::AST::SendNode] send_node
         # @return [String]

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

@@ -26,7 +26,31 @@ module RuboCop
                       "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
                         'configure using `TargetRubyVersion` parameter, under `AllCops`)'
                     end
-          add_offense(diagnostic.location, message: message, severity: diagnostic.level)
+          location = diagnostic_location(diagnostic.location)
+          add_offense(location, message: message, severity: diagnostic.level)
+        end
+
+        # Expand zero-length diagnostic ranges so that editors and formatters
+        # can display them. This typically occurs when the parser reports
+        # `unexpected token $end` at EOF.
+        def diagnostic_location(location)
+          return location if location.size.positive?
+
+          source_buffer = location.source_buffer
+          if location.end_pos < source_buffer.source.size
+            location.resize(1)
+          elsif location.begin_pos.positive?
+            location.adjust(begin_pos: -1)
+          else
+            location
+          end
+        end
+
+        # Override to skip multiline_ranges check which requires AST.
+        # Syntax errors mean the AST is nil, so we go directly to
+        # the EOL comment insertion path.
+        def disable_offense(offense_range)
+          disable_offense_with_eol_or_surround_comment(offense_range)
         end
 
         def add_offense_from_error(error)

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

@@ -32,6 +32,7 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+        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?

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

@@ -95,10 +95,20 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? && cop_config['AllowUnusedKeywordArguments']
           return if ignored_method?(variable.scope.node.body)
+          return if block_argument_with_yield?(variable)
 
           super
         end
 
+        def block_argument_with_yield?(variable)
+          return false unless variable.declaration_node.blockarg_type?
+
+          method_body = variable.scope.node.body
+          return false unless method_body
+
+          method_body.yield_type? || method_body.each_descendant(:yield).any?
+        end
+
         def ignored_method?(body)
           (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
             (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))

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

@@ -48,12 +48,12 @@ module RuboCop
 
         def after_private_modifier?(left_siblings)
           access_modifier_candidates = left_siblings.compact.select do |left_sibling|
-            left_sibling.respond_to?(:send_type?) && left_sibling.send_type?
+            left_sibling.respond_to?(:bare_access_modifier?) && left_sibling.bare_access_modifier?
           end
 
-          access_modifier_candidates.any? do |candidate|
-            candidate.command?(:private) && candidate.arguments.none?
-          end
+          return false if access_modifier_candidates.empty?
+
+          access_modifier_candidates.last.command?(:private)
         end
 
         def private_constantize?(right_siblings, const_value)

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

@@ -67,6 +67,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless node.receiver
+
           unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
             return
           end

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -82,28 +82,35 @@ module RuboCop
             !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
           end
 
-          # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           def sole_condition_of_parent_if?(node)
+            child = node
             parent = node.parent
 
             while parent
               if parent.if_type?
-                if parent.condition == node
-                  return true
-                elsif parent.elsif?
-                  parent = find_top_if(parent)
-                end
+                condition = parent.condition
+                return true if !child.equal?(condition) && non_nil_condition?(condition, node)
+
+                parent = find_top_if(parent) if parent.elsif?
               elsif else_branch?(parent)
                 # Find the top `if` for `else`.
                 parent = parent.parent
               end
 
+              child = parent
               parent = parent&.parent
             end
 
             false
           end
-          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          def non_nil_condition?(condition, node)
+            return true if condition == node
+
+            condition.csend_type? && csend_root_receiver(condition) == node
+          end
 
           def else_branch?(node)
             node.parent&.if_type? && node.parent.else_branch == node
@@ -114,6 +121,14 @@ module RuboCop
 
             node
           end
+
+          def csend_root_receiver(node)
+            return unless (receiver = node.receiver)
+
+            receiver = receiver.receiver while receiver.call_type? && receiver.receiver
+
+            receiver
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/check_single_line_suitability.rb

@@ -38,7 +38,7 @@ module RuboCop
       end
 
       def safe_to_split?(node)
-        node.each_descendant(:if, :case, :kwbegin, :any_def).none? &&
+        node.each_descendant(:if, :case, :kwbegin, :any_def, :rescue, :ensure).none? &&
           node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
           node.each_descendant(:begin, :sym).none?(&:multiline?)
       end

data/lib/rubocop/cop/registry.rb

@@ -16,7 +16,7 @@ module RuboCop
     end
 
     # Registry that tracks all cops by their badge and department.
-    class Registry
+    class Registry # rubocop:disable Metrics/ClassLength
       include Enumerable
 
       def self.all
@@ -46,7 +46,7 @@ module RuboCop
         global.qualify_badge(badge).first == badge
       end
 
-      attr_reader :options
+      attr_reader :options, :warnings
 
       def initialize(cops = [], options = {})
         @registry = {}
@@ -58,6 +58,7 @@ module RuboCop
 
         @enabled_cache = {}.compare_by_identity
         @disabled_cache = {}.compare_by_identity
+        @warnings = {}
       end
 
       def enlist(cop)
@@ -132,7 +133,7 @@ module RuboCop
       # @return [String] Qualified cop name
       def qualified_cop_name(name, path, warn: true)
         badge = Badge.parse(name)
-        print_warning(name, path) if warn && department_missing?(badge, name)
+        print_department_missing_warning(name, path) if warn && department_missing?(badge, name)
         return name if registered?(badge)
 
         potential_badges = qualify_badge(badge)
@@ -148,12 +149,12 @@ module RuboCop
         !badge.qualified? && unqualified_cop_names.include?(name)
       end
 
-      def print_warning(name, path)
-        message = "#{path}: Warning: no department given for #{name}."
+      def print_department_missing_warning(name, path)
+        message = "no department given for #{name}."
         if path.end_with?('.rb')
           message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
         end
-        warn message
+        emit_warning(path, message)
       end
 
       def unqualified_cop_names
@@ -274,6 +275,10 @@ module RuboCop
         attr_reader :global
       end
 
+      def warnings?(path)
+        @warnings[path]
+      end
+
       private
 
       def initialize_copy(reg)
@@ -297,18 +302,20 @@ module RuboCop
       end
 
       def resolve_badge(given_badge, real_badge, source_path, warn: true)
-        unless given_badge.match?(real_badge)
-          path = PathUtil.smart_path(source_path)
-
-          if warn
-            warn("#{path}: #{given_badge} has the wrong namespace - " \
-                 "replace it with #{given_badge.with_department(real_badge.department)}")
-          end
+        if warn && !given_badge.match?(real_badge)
+          emit_warning(source_path,
+                       "#{given_badge} has the wrong namespace - " \
+                       "replace it with #{given_badge.with_department(real_badge.department)}")
         end
 
         real_badge.to_s
       end
 
+      def emit_warning(path, message)
+        Registry.global.warnings[path] = true
+        warn "#{PathUtil.smart_path(path)}: Warning: #{message}"
+      end
+
       def registered?(badge)
         clear_enrollment_queue
         @registry.key?(badge)

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

@@ -348,8 +348,20 @@ module RuboCop
 
         def remove_modifier_node_within_begin(corrector, modifier_node, begin_node)
           def_node = begin_node.children[begin_node.children.index(modifier_node) + 1]
-          range = modifier_node.source_range.begin.join(def_node.source_range.begin)
-          corrector.remove(range)
+          # Stop the removal range at the first comment that precedes the def, if
+          # any exist. Without this, comments between the modifier and the def are
+          # dropped because they fall inside the removed range.
+          end_pos = first_comment_or_node_start(def_node)
+          corrector.remove(modifier_node.source_range.begin.join(end_pos))
+        end
+
+        def first_comment_or_node_start(node)
+          preceding = processed_source.ast_with_comments[node].select do |comment|
+            comment.loc.line < node.loc.line
+          end
+          return node.source_range.begin if preceding.empty?
+
+          preceding.first.source_range.begin
         end
 
         def def_source(node, def_nodes)

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

@@ -128,6 +128,7 @@ module RuboCop
 
         def correct_other(node, corrector)
           return if node.parenthesized_call?
+          return if node.children.empty? && node.equal?(node.parent.children.last)
 
           corrector.wrap(node, '(', ')')
         end

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

@@ -424,21 +424,39 @@ module RuboCop
           end
 
           def forwarded_rest_arg
-            return nil if referenced_rest_arg?
+            return @forwarded_rest_arg if defined?(@forwarded_rest_arg)
 
-            arguments.find { |arg| forwarded_rest_arg?(arg, @rest_arg_name) }
+            @forwarded_rest_arg = if referenced_rest_arg?
+                                    nil
+                                  else
+                                    arguments.find do |arg|
+                                      forwarded_rest_arg?(arg, @rest_arg_name)
+                                    end
+                                  end
           end
 
           def forwarded_kwrest_arg
-            return nil if referenced_kwrest_arg?
+            return @forwarded_kwrest_arg if defined?(@forwarded_kwrest_arg)
 
-            arguments.filter_map { |arg| extract_forwarded_kwrest_arg(arg, @kwrest_arg_name) }.first
+            @forwarded_kwrest_arg = if referenced_kwrest_arg?
+                                      nil
+                                    else
+                                      arguments.filter_map do |arg|
+                                        extract_forwarded_kwrest_arg(arg, @kwrest_arg_name)
+                                      end.first
+                                    end
           end
 
           def forwarded_block_arg
-            return nil if referenced_block_arg?
-
-            arguments.find { |arg| forwarded_block_arg?(arg, @block_arg_name) }
+            return @forwarded_block_arg if defined?(@forwarded_block_arg)
+
+            @forwarded_block_arg = if referenced_block_arg?
+                                     nil
+                                   else
+                                     arguments.find do |arg|
+                                       forwarded_block_arg?(arg, @block_arg_name)
+                                     end
+                                   end
           end
 
           def classification

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

@@ -52,7 +52,7 @@ module RuboCop
         end
 
         def allowed_non_ascii_chars
-          cop_config['AllowedChars'] || []
+          @allowed_non_ascii_chars ||= (cop_config['AllowedChars'] || []).freeze
         end
       end
     end