rubocop 1.79.2 → 1.87.0

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

@@ -112,22 +112,36 @@ module RuboCop
 
         def each_line_range(cop, line_ranges)
           line_ranges.each_with_index do |line_range, line_range_index|
-            next if ignore_offense?(line_range)
-            next if expected_final_disable?(cop, line_range)
+            next if should_skip_line_range?(cop, line_range)
 
             comment = processed_source.comment_at_line(line_range.begin)
-            redundant = if all_disabled?(comment)
-                          find_redundant_all(line_range, line_ranges[line_range_index + 1])
-                        elsif department_disabled?(cop, comment)
-                          find_redundant_department(cop, line_range)
-                        else
-                          find_redundant_cop(cop, line_range)
-                        end
+            next if skip_directive?(comment)
 
+            next_range = line_ranges[line_range_index + 1]
+            redundant = find_redundant_directive(cop, comment, line_range, next_range)
             yield comment, redundant if redundant
           end
         end
 
+        def should_skip_line_range?(cop, line_range)
+          ignore_offense?(line_range) || expected_final_disable?(cop, line_range)
+        end
+
+        def skip_directive?(comment)
+          directive = DirectiveComment.new(comment)
+          directive.push? || directive.pop?
+        end
+
+        def find_redundant_directive(cop, comment, line_range, next_range)
+          if all_disabled?(comment)
+            find_redundant_all(line_range, next_range)
+          elsif department_disabled?(cop, comment)
+            find_redundant_department(cop, line_range)
+          else
+            find_redundant_cop(cop, line_range)
+          end
+        end
+
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def each_already_disabled(cop, line_ranges)
           line_ranges.each_cons(2) do |previous_range, range|

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

@@ -1,19 +1,13 @@
 # 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
       # Detects instances of rubocop:enable comments that can be
       # removed.
       #
-      # When comment enables all cops at once `rubocop:enable all`
-      # that cop checks whether any cop was actually enabled.
+      # When a comment enables all cops at once `rubocop:enable all`
+      # the cop checks whether any cop was actually enabled.
       #
       # @example
       #
@@ -130,6 +124,3 @@ module RuboCop
     end
   end
 end
-
-# rubocop:enable Lint/RedundantCopDisableDirective
-# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -19,7 +19,8 @@ module RuboCop
       #   * 2.2+ ... Add `rational` and `complex` above
       #   * 2.7+ ... Add `ruby2_keywords` above
       #   * 3.1+ ... Add `fiber` above
-      #   * 3.2+ ... `set`
+      #   * 3.2+ ... Add `set` above
+      #   * 4.0+ ... Add `pathname` above
       #
       # This cop target those features.
       #
@@ -69,7 +70,8 @@ module RuboCop
             (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
             (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
             (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
-            (target_ruby_version >= 3.2 && feature_name == 'set')
+            (target_ruby_version >= 3.2 && feature_name == 'set') ||
+            (target_ruby_version >= 4.0 && feature_name == 'pathname')
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end

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, '.') }

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

@@ -77,7 +77,7 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'
         PERCENT_I = '%i'
         PERCENT_CAPITAL_I = '%I'
-        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
         # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
@@ -144,7 +144,9 @@ module RuboCop
             expression = node.parent.source_range if node.parent.array_type?
             [expression, variable.source]
           elsif !variable.array_type?
-            [expression, "[#{variable.source}]"]
+            replacement = variable.source
+            replacement = "[#{replacement}]" if wrap_in_brackets?(node)
+            [expression, replacement]
           elsif redundant_brackets?(node)
             [expression, remove_brackets(variable)]
           else
@@ -176,6 +178,10 @@ module RuboCop
             grandparent&.resbody_type?
         end
 
+        def wrap_in_brackets?(node)
+          node.parent.array_type? && !node.parent.bracketed?
+        end
+
         def remove_brackets(array)
           array_start = array.loc.begin.source
           elements = *array

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

@@ -17,14 +17,14 @@ module RuboCop
       #   or with `String.new` or `String()`.
       # * `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 of with `Float()`.
+      # * `to_f` when called on a float literal or with `Float()`.
       # * `to_r` when called on a rational literal or with `Rational()`.
-      # * `to_c` when called on a complex literal of with `Complex()`.
+      # * `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[]`.
       # * `to_h` when called on a hash literal, or with `Hash.new`, `Hash()` or `Hash[]`.
       # * `to_set` when called on `Set.new` or `Set[]`.
       #
-      # In all cases, chaining one same `to_*` conversion methods listed above is redundant.
+      # In all cases, chaining one of the same `to_*` conversion methods listed above is redundant.
       #
       # The cop can also register an offense for chaining conversion methods on methods that are
       # expected to return a specific type regardless of receiver (eg. `foo.inspect.to_s` and

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for uses a file requiring itself with `require_relative`.
+      # Checks for a file requiring itself with `require_relative`.
       #
       # @example
       #
@@ -38,6 +38,8 @@ module RuboCop
         private
 
         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
 

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

@@ -24,10 +24,7 @@ module RuboCop
         MSG = 'Avoid rescuing the `Exception` class. Perhaps you meant to rescue `StandardError`?'
 
         def on_resbody(node)
-          return unless node.children.first
-
-          rescue_args = node.children.first.children
-          return unless rescue_args.any? { |a| targets_exception?(a) }
+          return unless node.exceptions.any? { |exception| targets_exception?(exception) }
 
           add_offense(node)
         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/safe_navigation_consistency.rb

@@ -3,10 +3,16 @@
 module RuboCop
   module Cop
     module Lint
-      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # Checks that if safe navigation is used in an `&&` or `||` condition,
       # consistent and appropriate safe navigation, without excess or deficiency,
       # is used for all method calls on the same object.
       #
+      # @safety
+      #   Autocorrection is unsafe because if the receiver is not a local variable
+      #   but a method call, it may not be idempotent. For example, replacing
+      #   `foo&.bar` with `foo.bar` could raise `NoMethodError` if `foo` returns
+      #   `nil` on a subsequent call.
+      #
       # @example
       #   # bad
       #   foo&.bar && foo&.baz

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

@@ -23,7 +23,15 @@ module RuboCop
       #   # good (method calls possibly can return different results)
       #   hash[foo] = hash[foo]
       #
-      # @example AllowRBSInlineAnnotation:true
+      # @example AllowRBSInlineAnnotation: false (default)
+      #   # bad
+      #   foo = foo #: Integer
+      #   foo, bar = foo, bar #: Integer
+      #   Foo = Foo #: Integer
+      #   hash['foo'] = hash['foo'] #: Integer
+      #   obj.attr = obj.attr #: Integer
+      #
+      # @example AllowRBSInlineAnnotation: true
       #   # good
       #   foo = foo #: Integer
       #   foo, bar = foo, bar #: Integer
@@ -45,7 +53,7 @@ module RuboCop
           return if allow_rbs_inline_annotation? && rbs_inline_annotation?(node.receiver)
 
           if node.method?(:[]=)
-            handle_key_assignment(node) if node.arguments.size == 2
+            handle_key_assignment(node)
           elsif node.assignment_method?
             handle_attribute_assignment(node) if node.arguments.size == 1
           end
@@ -105,12 +113,13 @@ module RuboCop
         end
 
         def handle_key_assignment(node)
-          value_node = node.arguments[1]
+          value_node = node.last_argument
+          node_arguments = node.arguments[0...-1]
 
-          if value_node.send_type? && value_node.method?(:[]) &&
+          if value_node.respond_to?(:method?) && value_node.method?(:[]) &&
              node.receiver == value_node.receiver &&
-             !node.first_argument.call_type? &&
-             node.first_argument == value_node.first_argument
+             node_arguments.none?(&:call_type?) &&
+             node_arguments == value_node.arguments
             add_offense(node)
           end
         end

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

@@ -125,13 +125,13 @@ module RuboCop
             next false if assignment_node.shorthand_asgn?
             next false unless assignment_node.parent
 
-            node_within_block_or_conditional =
-              node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)
+            conditional_assignment =
+              conditional_assignment?(assignment_node.parent, argument.scope.node)
 
             unless uses_var?(assignment_node, argument.name)
               # It's impossible to decide whether a branch or block is executed,
               # so the precise reassignment location is undecidable.
-              next false if node_within_block_or_conditional
+              next false if conditional_assignment
 
               yield(assignment.node, location_known)
               break
@@ -147,13 +147,13 @@ module RuboCop
           node.source_range.begin_pos
         end
 
-        # Check whether the given node is nested into block or conditional.
+        # Check whether the given node is always executed or not
         #
-        def node_within_block_or_conditional?(node, stop_search_node)
+        def conditional_assignment?(node, stop_search_node)
           return false if node == stop_search_node
 
-          node.conditional? || node.block_type? ||
-            node_within_block_or_conditional?(node.parent, stop_search_node)
+          node.conditional? || node.type?(:block, :rescue) ||
+            conditional_assignment?(node.parent, stop_search_node)
         end
 
         # Get argument references without assignments' references

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for a rescued exception that get shadowed by a
+      # Checks for a rescued exception that gets shadowed by a
       # less specific exception being rescued before a more specific
       # exception is rescued.
       #

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

@@ -26,7 +26,23 @@ module RuboCop
               'and it may be unexpected.'
         RESTRICT_ON_SEND = %i[new].freeze
 
-        STRUCT_METHOD_NAMES = Struct.instance_methods
+        # This is based on `Struct.instance_methods.sort` in Ruby 4.0.0.
+        STRUCT_METHOD_NAMES = %i[
+          ! != !~ <=> == === [] []= __id__ __send__ all? any? chain chunk chunk_while class clone
+          collect collect_concat compact count cycle deconstruct deconstruct_keys
+          define_singleton_method detect dig display drop drop_while dup each each_cons each_entry
+          each_pair each_slice each_with_index each_with_object entries enum_for eql? equal? extend
+          filter filter_map find find_all find_index first flat_map freeze frozen? grep grep_v
+          group_by hash include? inject inspect instance_eval instance_exec instance_of?
+          instance_variable_defined? instance_variable_get instance_variable_set instance_variables
+          is_a? itself kind_of? lazy length map max max_by member? members method methods
+          min min_by minmax minmax_by nil? none? object_id one? partition private_methods
+          protected_methods public_method public_methods public_send reduce reject
+          remove_instance_variable respond_to? reverse_each select send singleton_class
+          singleton_method singleton_methods size slice_after slice_before slice_when sort sort_by
+          sum take take_while tally tap then to_a to_enum to_h to_s to_set uniq values values_at
+          yield_self zip
+        ].freeze
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
 
         # @!method struct_new(node)

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

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # Checks for Regexps (both literals and via `Regexp.new` / `Regexp.compile`)
       # that contain unescaped `]` characters.
       #
       # It emulates the following Ruby warning:

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

@@ -120,6 +120,7 @@ module RuboCop
           check_return_values(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # Checks for unreachable code.
-      # The check are based on the presence of flow of control
-      # statement in non-final position in `begin` (implicit) blocks.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
       #
       # @example
       #
@@ -78,6 +78,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -89,12 +90,14 @@ module RuboCop
             check_if(node)
           when :case, :case_match
             check_case(node)
-          when :def
+          when :def, :defs
             register_redefinition(node)
+            false
           else
             false
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         def check_if(node)
           if_branch = node.if_branch
@@ -113,8 +116,7 @@ module RuboCop
         end
 
         def register_redefinition(node)
-          @redefined << node.method_name if redefinable_flow_method? node.method_name
-          false
+          @redefined << node.method_name if redefinable_flow_method?(node.method_name)
         end
 
         def instance_eval_block?(node)