rubocop 1.78.0 → 1.81.6

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

@@ -20,6 +20,15 @@ module RuboCop
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # The `InferNonNilReceiver` option specifies whether to look into previous code
+      # paths to infer if the receiver can't be nil. This check is unsafe because the receiver
+      # can be redefined between the safe navigation call and previous regular method call.
+      # It does the inference only in the current scope, e.g. within the same method definition etc.
+      #
+      # The `AdditionalNilMethods` option specifies additional custom methods which are
+      # defined on `NilClass`. When `InferNonNilReceiver` is set, they are used to determine
+      # whether the receiver can be nil.
+      #
       # @safety
       #   This cop is unsafe, because autocorrection can change the return type of
       #   the expression. An offending expression that previously could return `nil`
@@ -33,6 +42,20 @@ module RuboCop
       #   CamelCaseConst.do_something
       #
       #   # bad
+      #   foo.to_s&.strip
+      #   foo.to_i&.zero?
+      #   foo.to_f&.zero?
+      #   foo.to_a&.size
+      #   foo.to_h&.size
+      #
+      #   # good
+      #   foo.to_s.strip
+      #   foo.to_i.zero?
+      #   foo.to_f.zero?
+      #   foo.to_a.size
+      #   foo.to_h.size
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -81,17 +104,59 @@ module RuboCop
       #   do_something if attrs.nil_safe_method(:[])
       #   do_something if attrs&.not_nil_safe_method(:[])
       #
+      # @example InferNonNilReceiver: false (default)
+      #   # good
+      #   foo.bar
+      #   foo&.baz
+      #
+      # @example InferNonNilReceiver: true
+      #   # bad
+      #   foo.bar
+      #   foo&.baz # would raise on previous line if `foo` is nil
+      #
+      #   # good
+      #   foo.bar
+      #   foo.baz
+      #
+      #   # bad
+      #   if foo.condition?
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   if foo.condition?
+      #     foo.bar
+      #   end
+      #
+      #   # good (different scopes)
+      #   def method1
+      #     foo.bar
+      #   end
+      #
+      #   def method2
+      #     foo&.bar
+      #   end
+      #
+      # @example AdditionalNilMethods: [present?]
+      #   # good
+      #   foo.present?
+      #   foo&.bar
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
         extend AutoCorrector
 
         MSG = 'Redundant safe navigation detected, use `.` instead.'
         MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+        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
 
         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))
@@ -111,15 +176,27 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_csend(node)
+          range = node.loc.dot
+
+          if infer_non_nil_receiver?
+            checker = Lint::Utils::NilReceiverChecker.new(node.receiver, additional_nil_methods)
+
+            if checker.cant_be_nil?
+              add_offense(range, message: MSG_NON_NIL) { |corrector| corrector.replace(range, '.') }
+              return
+            end
+          end
+
           unless assume_receiver_instance_exists?(node.receiver)
-            return unless check?(node) && allowed_method?(node.method_name)
+            return if !guaranteed_instance?(node.receiver) && !check?(node)
             return if respond_to_nil_specific_method?(node)
           end
 
-          range = node.loc.dot
           add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
+        # rubocop:enable Metrics/AbcSize
 
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           conversion_with_default?(node) do |send_node|
             range = send_node.loc.dot.begin.join(node.source_range.end)
@@ -142,7 +219,20 @@ module RuboCop
           receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
         end
 
+        def guaranteed_instance?(node)
+          receiver = if node.any_block_type?
+                       node.send_node
+                     else
+                       node
+                     end
+          return false unless receiver.send_type?
+
+          GUARANTEED_INSTANCE_METHODS.include?(receiver.method_name)
+        end
+
         def check?(node)
+          return false unless allowed_method?(node.method_name)
+
           parent = node.parent
           return false unless parent
 
@@ -154,6 +244,15 @@ module RuboCop
         def condition?(parent, node)
           (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
         end
+
+        def infer_non_nil_receiver?
+          cop_config['InferNonNilReceiver']
+        end
+
+        def additional_nil_methods
+          @additional_nil_methods ||=
+            Array(cop_config.fetch('AdditionalNilMethods', []).map(&:to_sym))
+        end
       end
     end
   end

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

@@ -43,7 +43,7 @@ module RuboCop
         def on_irange(node)
           return if node.parent&.begin_type?
           return unless node.begin && node.end
-          return if same_line?(node.begin, node.end)
+          return if same_line?(node.loc.operator, node.end)
 
           message = format(MSG, range: "#{node.begin.source}#{node.loc.operator.source}")
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Check for arguments to `rescue` that will result in a `TypeError`
+      # Checks for arguments to `rescue` that will result in a `TypeError`
       # if an exception is raised.
       #
       # @example

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

@@ -45,7 +45,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 +105,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/uri_escape_unescape.rb

@@ -17,6 +17,7 @@ module RuboCop
       #
       #   # good
       #   CGI.escape('http://example.com')
+      #   URI.encode_uri_component(uri) # Since Ruby 3.1
       #   URI.encode_www_form([['example', 'param'], ['lang', 'en']])
       #   URI.encode_www_form(page: 10, locale: 'en')
       #   URI.encode_www_form_component('http://example.com')
@@ -27,6 +28,7 @@ module RuboCop
       #
       #   # good
       #   CGI.unescape(enc_uri)
+      #   URI.decode_uri_component(uri) # Since Ruby 3.1
       #   URI.decode_www_form(enc_uri)
       #   URI.decode_www_form_component(enc_uri)
       class UriEscapeUnescape < Base

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

@@ -31,6 +31,7 @@ module RuboCop
       #
       class UselessNumericOperation < Base
         extend AutoCorrector
+
         MSG = 'Do not apply inconsequential numeric operations to variables.'
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      module Utils
+        # Utility class that checks if the receiver can't be nil.
+        class NilReceiverChecker
+          NIL_METHODS = (nil.methods + %i[!]).to_set.freeze
+
+          def initialize(receiver, additional_nil_methods)
+            @receiver = receiver
+            @additional_nil_methods = additional_nil_methods
+            @checked_nodes = {}.compare_by_identity
+          end
+
+          def cant_be_nil?
+            sole_condition_of_parent_if?(@receiver) || _cant_be_nil?(@receiver.parent, @receiver)
+          end
+
+          private
+
+          # rubocop:disable Metrics
+          def _cant_be_nil?(node, receiver)
+            return false unless node
+
+            # For some nodes, we check their parent and then some children for these parents.
+            # This is added to avoid infinite loops.
+            return false if @checked_nodes.key?(node)
+
+            @checked_nodes[node] = true
+
+            case node.type
+            when :def, :class, :module, :sclass
+              return false
+            when :send
+              return non_nil_method?(node.method_name) if node.receiver == receiver
+
+              node.arguments.each do |argument|
+                return true if _cant_be_nil?(argument, receiver)
+              end
+
+              return true if _cant_be_nil?(node.receiver, receiver)
+            when :begin
+              return true if _cant_be_nil?(node.children.first, receiver)
+            when :if, :case
+              return true if _cant_be_nil?(node.condition, receiver)
+            when :and, :or
+              return true if _cant_be_nil?(node.lhs, receiver)
+            when :pair
+              if _cant_be_nil?(node.key, receiver) ||
+                 _cant_be_nil?(node.value, receiver)
+                return true
+              end
+            when :when
+              node.each_condition do |condition|
+                return true if _cant_be_nil?(condition, receiver)
+              end
+            when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :casgn
+              return true if _cant_be_nil?(node.expression, receiver)
+            end
+
+            # Due to how `if/else` are implemented (`elsif` is a child of `if` or another `elsif`),
+            # using left_siblings will not work correctly for them.
+            if !else_branch?(node) || (node.if_type? && !node.elsif?)
+              node.left_siblings.reverse_each do |sibling|
+                next unless sibling.is_a?(AST::Node)
+
+                return true if _cant_be_nil?(sibling, receiver)
+              end
+            end
+
+            if node.parent
+              _cant_be_nil?(node.parent, receiver)
+            else
+              false
+            end
+          end
+          # rubocop:enable Metrics
+
+          def non_nil_method?(method_name)
+            !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
+          end
+
+          # rubocop:disable Metrics/PerceivedComplexity
+          def sole_condition_of_parent_if?(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
+              elsif else_branch?(parent)
+                # Find the top `if` for `else`.
+                parent = parent.parent
+              end
+
+              parent = parent&.parent
+            end
+
+            false
+          end
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def else_branch?(node)
+            node.parent&.if_type? && node.parent.else_branch == node
+          end
+
+          def find_top_if(node)
+            node = node.parent while node.elsif?
+
+            node
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,12 @@ module RuboCop
       # enumerator.each { |item| item >= 2 } #=> [2, 3]
       # ----
       #
+      # NOTE: Return values in assignment method definitions such as `def foo=(arg)` are
+      # detected because they are in a void context. However, autocorrection does not remove
+      # the return value, as that would change behavior. In such cases, whether to remove
+      # the return value or rename the method to something more appropriate should be left to
+      # the user.
+      #
       # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
       #   def some_method
@@ -233,6 +239,7 @@ module RuboCop
 
         def autocorrect_void_expression(corrector, node)
           return if node.parent.if_type?
+          return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
 
           corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
         end

data/lib/rubocop/cop/message_annotator.rb

@@ -102,7 +102,7 @@ module RuboCop
       def reference_urls
         urls = cop_config
                .values_at('References', 'Reference') # Support legacy Reference key
-               .flat_map { Array(_1) }
+               .flat_map { |url| Array(url) }
                .reject(&:empty?)
 
         urls unless urls.empty?

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

@@ -227,7 +227,7 @@ module RuboCop
 
       def chained_to_heredoc?(node)
         while (node = node.receiver)
-          return true if node.type?(:str, :dstr, :xstr) && node.heredoc?
+          return true if node.any_str_type? && node.heredoc?
         end
 
         false

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

@@ -19,8 +19,7 @@ module RuboCop
       def check_end_kw_alignment(node, align_ranges)
         return if ignored_node?(node)
 
-        end_loc = node.loc.end
-        return if accept_end_kw_alignment?(end_loc)
+        return unless (end_loc = node.loc.end)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -57,11 +56,6 @@ module RuboCop
         add_offense(end_loc, message: msg) { |corrector| autocorrect(corrector, node) }
       end
 
-      def accept_end_kw_alignment?(end_loc)
-        end_loc.nil? || # Discard modifier forms of if/while/until.
-          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
-      end
-
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -140,7 +140,7 @@ module RuboCop
       end
 
       def last_item_precedes_newline?(node)
-        after_last_item = node.children.last.source_range.end.join(node.loc.end.begin)
+        after_last_item = node.children.last.source_range.end.join(node.source_range.end)
 
         after_last_item.source.start_with?(/,?\s*(#.*)?\n/)
       end

data/lib/rubocop/cop/naming/method_name.rb

@@ -53,6 +53,12 @@ module RuboCop
       #   # good
       #   Struct.new(:foo_bar)
       #
+      #   # bad
+      #   alias_method :fooBar, :some_method
+      #
+      #   # good
+      #   alias_method :foo_bar, :some_method
+      #
       # @example EnforcedStyle: camelCase
       #   # bad
       #   def foo_bar; end
@@ -74,6 +80,12 @@ module RuboCop
       #   # good
       #   Struct.new(:fooBar)
       #
+      #   # bad
+      #   alias_method :foo_bar, :some_method
+      #
+      #   # good
+      #   alias_method :fooBar, :some_method
+      #
       # @example ForbiddenIdentifiers: ['def', 'super']
       #   # bad
       #   def def; end
@@ -94,6 +106,9 @@ module RuboCop
         MSG = 'Use %<style>s for method names.'
         MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
 
+        OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
+                              % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
@@ -103,11 +118,18 @@ module RuboCop
         # @!method new_struct?(node)
         def_node_matcher :new_struct?, '(send (const {nil? cbase} :Struct) :new ...)'
 
+        # @!method define_data?(node)
+        def_node_matcher :define_data?, '(send (const {nil? cbase} :Data) :define ...)'
+
         def on_send(node)
           if node.method?(:define_method) || node.method?(:define_singleton_method)
             handle_define_method(node)
           elsif new_struct?(node)
             handle_new_struct(node)
+          elsif define_data?(node)
+            handle_define_data(node)
+          elsif node.method?(:alias_method)
+            handle_alias_method(node)
           else
             handle_attr_accessor(node)
           end
@@ -124,6 +146,10 @@ module RuboCop
         end
         alias on_defs on_def
 
+        def on_alias(node)
+          handle_method_name(node.new_identifier, node.new_identifier.value)
+        end
+
         private
 
         def handle_define_method(node)
@@ -139,6 +165,19 @@ module RuboCop
           end
         end
 
+        def handle_define_data(node)
+          node.arguments.select { |argument| argument.type?(:sym, :str) }.each do |name|
+            handle_method_name(name, name.value)
+          end
+        end
+
+        def handle_alias_method(node)
+          return unless node.arguments.size == 2
+          return unless node.first_argument.type?(:str, :sym)
+
+          handle_method_name(node.first_argument, node.first_argument.value)
+        end
+
         def handle_attr_accessor(node)
           return unless (attrs = node.attribute_accessor?)
 
@@ -159,7 +198,7 @@ module RuboCop
 
           if forbidden_name?(name.to_s)
             register_forbidden_name(node)
-          else
+          elsif !OPERATOR_METHODS.include?(name.to_sym)
             check_name(node, name, range_position(node))
           end
         end

data/lib/rubocop/cop/naming/predicate_method.rb

@@ -14,7 +14,7 @@ module RuboCop
       # method calls are assumed to return boolean values. The cop does not make an assessment
       # if the return type is unknown (non-predicate method calls, variables, etc.).
       #
-      # NOTE: Operator methods (`def ==`, etc.) are ignored.
+      # NOTE: The `initialize` method and operator methods (`def ==`, etc.) are ignored.
       #
       # By default, the cop runs in `conservative` mode, which allows a method to be named
       # with a question mark as long as at least one return value is boolean. In `aggressive`
@@ -113,6 +113,18 @@ module RuboCop
       #     true
       #   end
       #
+      # @example AllowedMethods: [call] (default)
+      #   # good
+      #   def call
+      #     foo == bar
+      #   end
+      #
+      # @example AllowedPatterns: [\Afoo]
+      #   # good
+      #   def foo?
+      #     'foo'
+      #   end
+      #
       # @example AllowBangMethods: false (default)
       #   # bad
       #   def save!
@@ -149,7 +161,8 @@ module RuboCop
         private
 
         def allowed?(node)
-          allowed_method?(node.method_name) ||
+          node.method?(:initialize) ||
+            allowed_method?(node.method_name) ||
             matches_allowed_pattern?(node.method_name) ||
             allowed_bang_method?(node) ||
             node.operator_method? ||
@@ -269,7 +282,10 @@ module RuboCop
             node.body ? [last_value(node.body)] : [s(:nil)]
           else
             # Branches with no value act as an implicit `nil`.
-            node.branches.filter_map { |branch| branch ? last_value(branch) : s(:nil) }
+            branches = node.branches.map { |branch| branch ? last_value(branch) : s(:nil) }
+            # Missing else branches also act as an implicit `nil`.
+            branches.push(s(:nil)) unless node.else_branch
+            branches
           end
         end