rubocop 1.65.1 → 1.75.6

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

@@ -32,6 +32,23 @@ module RuboCop
       class UnreachableCode < Base
         MSG = 'Unreachable code detected.'
 
+        def initialize(config = nil, options = nil)
+          super
+          @redefined = []
+          @instance_eval_count = 0
+        end
+
+        def on_block(node)
+          @instance_eval_count += 1 if instance_eval_block?(node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def after_block(node)
+          @instance_eval_count -= 1 if instance_eval_block?(node)
+        end
+
         def on_begin(node)
           expressions = *node
 
@@ -46,19 +63,23 @@ module RuboCop
 
         private
 
+        def redefinable_flow_method?(method)
+          %i[raise fail throw exit exit! abort].include? method
+        end
+
         # @!method flow_command?(node)
         def_node_matcher :flow_command?, <<~PATTERN
           {
             return next break retry redo
             (send
              {nil? (const {nil? cbase} :Kernel)}
-             {:raise :fail :throw :exit :exit! :abort}
+             #redefinable_flow_method?
              ...)
           }
         PATTERN
 
         def flow_expression?(node)
-          return true if flow_command?(node)
+          return report_on_flow_command?(node) if flow_command?(node)
 
           case node.type
           when :begin, :kwbegin
@@ -68,6 +89,8 @@ module RuboCop
             check_if(node)
           when :case, :case_match
             check_case(node)
+          when :def
+            register_redefinition(node)
           else
             false
           end
@@ -88,6 +111,33 @@ module RuboCop
 
           branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
+
+        def register_redefinition(node)
+          @redefined << node.method_name if redefinable_flow_method? node.method_name
+          false
+        end
+
+        def instance_eval_block?(node)
+          node.any_block_type? && node.method?(:instance_eval)
+        end
+
+        def report_on_flow_command?(node)
+          return true unless node.send_type?
+
+          # By the contract of this function, this case means that
+          # the method is called on `Kernel` in which case we
+          # always want to report a warning.
+          return true if node.receiver
+
+          # Inside an `instance_eval` we have no way to tell the
+          # type of `self` just by looking at the AST, so we can't
+          # tell if the give function that's called has been
+          # redefined or not, so to avoid false positives, we silence
+          # the warning.
+          return false if @instance_eval_count.positive?
+
+          !@redefined.include? node.method_name
+        end
       end
     end
   end

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

@@ -101,14 +101,13 @@ module RuboCop
           check(node) if loop_method?(node)
         end
 
-        def on_numblock(node)
-          check(node) if loop_method?(node)
-        end
+        alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def loop_method?(node)
-          return false unless node.block_type? || node.numblock_type?
+          return false unless node.any_block_type?
 
           send_node = node.send_node
           loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
@@ -189,8 +188,9 @@ module RuboCop
 
         def preceded_by_continue_statement?(break_statement)
           break_statement.left_siblings.any? do |sibling|
-            # Numblocks have the arguments count as a number in the AST.
-            next if sibling.is_a?(Integer)
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(*CONTINUE_KEYWORDS).any?

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

@@ -39,6 +39,8 @@ module RuboCop
       #   end
       #
       # @example IgnoreNotImplementedMethods: true (default)
+      #   # with default value of `NotImplementedExceptions: ['NotImplementedError']`
+      #
       #   # good
       #   def do_something(unused)
       #     raise NotImplementedError
@@ -48,6 +50,14 @@ module RuboCop
       #     fail "TODO"
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true
+      #   # with `NotImplementedExceptions: ['AbstractMethodError']`
+      #
+      #   # good
+      #   def do_something(unused)
+      #     raise AbstractMethodError
+      #   end
+      #
       # @example IgnoreNotImplementedMethods: false
       #   # bad
       #   def do_something(unused)
@@ -57,14 +67,13 @@ module RuboCop
       #   def do_something_else(unused)
       #     fail "TODO"
       #   end
-      #
       class UnusedMethodArgument < Base
         include UnusedArgument
         extend AutoCorrector
 
         # @!method not_implemented?(node)
         def_node_matcher :not_implemented?, <<~PATTERN
-          {(send nil? :raise (const {nil? cbase} :NotImplementedError) ...)
+          {(send nil? :raise #allowed_exception_class? ...)
            (send nil? :fail ...)}
         PATTERN
 
@@ -115,6 +124,13 @@ module RuboCop
 
           message
         end
+
+        def allowed_exception_class?(node)
+          return false unless node.const_type?
+
+          allowed_class_names = Array(cop_config.fetch('NotImplementedExceptions', []))
+          allowed_class_names.include?(node.const_name)
+        end
       end
     end
   end

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

@@ -3,29 +3,47 @@
 module RuboCop
   module Cop
     module Lint
-      # Identifies places where `URI.regexp` is obsolete and should
-      # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
+      # Identifies places where `URI.regexp` is obsolete and should not be used.
+      #
+      # For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+      # For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+      #
+      # NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+      # consider manually changing the code as follows:
+      #
+      # [source,ruby]
+      # ----
+      # defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+      # ----
       #
       # @example
       #   # bad
       #   URI.regexp('http://example.com')
       #
-      #   # good
+      #   # good - Ruby 3.3 or lower
       #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
       #
+      #   # good - Ruby 3.4 or higher
+      #   URI::RFC2396_PARSER.make_regexp('http://example.com')
+      #
       class UriRegexp < Base
         extend AutoCorrector
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
-        URI_CONSTANTS = ['URI', '::URI'].freeze
         RESTRICT_ON_SEND = %i[regexp].freeze
 
+        # @!method uri_constant?(node)
+        def_node_matcher :uri_constant?, <<~PATTERN
+          (const {cbase nil?} :URI)
+        PATTERN
+
         def on_send(node)
-          return unless node.receiver
-          return unless URI_CONSTANTS.include?(node.receiver.source)
+          return unless uri_constant?(node.receiver)
 
+          parser = target_ruby_version >= 3.4 ? 'RFC2396_PARSER' : 'DEFAULT_PARSER'
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''
-          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+
+          preferred_method = "#{node.receiver.source}::#{parser}.make_regexp#{argument}"
           message = format(MSG, current: node.source, preferred: preferred_method)
 
           add_offense(node.loc.selector, message: message) do |corrector|

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

@@ -143,6 +143,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -159,12 +160,12 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
+          (any_block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -268,7 +269,7 @@ module RuboCop
         end
 
         def start_of_new_scope?(child)
-          child.module_type? || child.class_type? || child.sclass_type? || eval_call?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
         end
 
         def eval_call?(child)
@@ -282,7 +283,7 @@ module RuboCop
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
+                (any_block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -16,15 +16,14 @@ module RuboCop
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
       #
+      # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
+      # operator assignment can cause `NameError` if this assignment has been used to declare
+      # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
+      # "undefined local variable or method `a' for main:Object (NameError)".
+      #
       # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
       # can lead to a syntax error, so this case is not autocorrected.
       #
-      # @safety
-      #   This cop's autocorrection is unsafe because removing assignment from
-      #   operator assignment can cause NameError if this assignment has been used to declare
-      #   local variable. For example, replacing `a ||= 1` to `a || 1` may cause
-      #   "undefined local variable or method `a' for main:Object (NameError)".
-      #
       # @example
       #
       #   # bad
@@ -53,24 +52,32 @@ module RuboCop
           scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
         def check_for_unused_assignments(variable)
           return if variable.should_be_unused?
 
           variable.assignments.reverse_each do |assignment|
-            next if assignment.used? || part_of_ignored_node?(assignment.node)
+            assignment_node = assignment.node
+            next if assignment.used? || part_of_ignored_node?(assignment_node)
 
             message = message_for_useless_assignment(assignment)
             range = offense_range(assignment)
 
             add_offense(range, message: message) do |corrector|
-              autocorrect(corrector, assignment) unless sequential_assignment?(assignment.node)
+              # In cases like `x = 1, y = 2`, where removing a variable would cause a syntax error,
+              # and where changing `x ||= 1` to `x = 1` would cause `NameError`,
+              # the autocorrect will be skipped, even if the variable is unused.
+              if sequential_assignment?(assignment_node) || assignment_node.parent&.or_asgn_type?
+                next
+              end
+
+              autocorrect(corrector, assignment)
             end
 
-            ignore_node(assignment.node) if chained_assignment?(assignment.node)
+            ignore_node(assignment_node) if chained_assignment?(assignment_node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
@@ -97,6 +104,8 @@ module RuboCop
         end
 
         def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
           node.respond_to?(:expression) && node.expression&.lvasgn_type?
         end
 

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        def on_casgn(node)
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+
+          add_offense(node)
+        end
+
+        private
+
+        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?
+          end
+
+          access_modifier_candidates.any? do |candidate|
+            candidate.command?(:private) && candidate.arguments.none?
+          end
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for calls to `defined?` with strings or symbols as the argument.
+      # Such calls will always return `'expression'`, you probably meant to
+      # check for the existence of a constant, method, or variable instead.
+      #
+      # `defined?` is part of the Ruby syntax and doesn't behave like normal methods.
+      # You can safely pass in what you are checking for directly, without encountering
+      # a `NameError`.
+      #
+      # When interpolation is used, oftentimes it is not possible to write the
+      # code with `defined?`. In these cases, switch to one of the more specific methods:
+      #
+      # * `class_variable_defined?`
+      # * `const_defined?`
+      # * `method_defined?`
+      # * `instance_variable_defined?`
+      # * `binding.local_variable_defined?`
+      #
+      # @example
+      #
+      #   # bad
+      #   defined?('FooBar')
+      #   defined?(:FooBar)
+      #   defined?(:foo_bar)
+      #   defined?('foo_bar')
+      #
+      #   # good
+      #   defined?(FooBar)
+      #   defined?(foo_bar)
+      #
+      #   # bad - interpolation
+      #   bar = 'Bar'
+      #   defined?("Foo::#{bar}::Baz")
+      #
+      #   # good
+      #   bar = 'Bar'
+      #   defined?(Foo) && Foo.const_defined?(bar) && Foo.const_get(bar).const_defined?(:Baz)
+      class UselessDefined < Base
+        MSG = 'Calling `defined?` with a %<type>s argument will always return a truthy value.'
+        TYPES = { str: 'string', dstr: 'string', sym: 'symbol', dsym: 'symbol' }.freeze
+
+        def on_defined?(node)
+          # NOTE: `defined?` always takes one argument. Anything else is a syntax error.
+          return unless (type = TYPES[node.first_argument.type])
+
+          add_offense(node, message: format(MSG, type: type))
+        end
+      end
+    end
+  end
+end

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

@@ -25,8 +25,12 @@ module RuboCop
       #     do_something_else
       #   end
       class UselessElseWithoutRescue < Base
+        extend TargetRubyVersion
+
         MSG = '`else` without `rescue` is useless.'
 
+        maximum_target_ruby_version 2.5
+
         def on_new_investigation
           processed_source.diagnostics.each do |diagnostic|
             next unless diagnostic.reason == :useless_else

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Certain numeric operations have no impact, being:
+      # Adding or subtracting 0, multiplying or dividing by 1 or raising to the power of 1.
+      # These are probably leftover from debugging, or are mistakes.
+      #
+      # @example
+      #
+      #   # bad
+      #   x + 0
+      #   x - 0
+      #   x * 1
+      #   x / 1
+      #   x ** 1
+      #
+      #   # good
+      #   x
+      #
+      #   # bad
+      #   x += 0
+      #   x -= 0
+      #   x *= 1
+      #   x /= 1
+      #   x **= 1
+      #
+      #   # good
+      #   x = x
+      #
+      class UselessNumericOperation < Base
+        extend AutoCorrector
+        MSG = 'Do not apply inconsequential numeric operations to variables.'
+        RESTRICT_ON_SEND = %i[+ - * / **].freeze
+
+        # @!method useless_operation?(node)
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
+
+        # @!method useless_abbreviated_assignment?(node)
+        def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
+
+        def on_send(node)
+          return unless useless_operation?(node)
+
+          variable, operation, number = useless_operation?(node)
+          return unless useless?(operation, number)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, variable)
+          end
+        end
+        alias on_csend on_send
+
+        def on_op_asgn(node)
+          return unless useless_abbreviated_assignment?(node)
+
+          variable, operation, number = useless_abbreviated_assignment?(node)
+          return unless useless?(operation, number)
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{variable} = #{variable}")
+          end
+        end
+
+        private
+
+        def useless?(operation, number)
+          if number.zero?
+            true if %i[+ -].include?(operation)
+          elsif number == 1
+            true if %i[* / **].include?(operation)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for useless `rescue`s, which only reraise rescued exceptions.
+      # Checks for useless ``rescue``s, which only reraise rescued exceptions.
       #
       # @example
       #   # bad
@@ -75,7 +75,7 @@ module RuboCop
         def use_exception_variable_in_ensure?(resbody_node)
           return false unless (exception_variable = resbody_node.exception_variable)
           return false unless (ensure_node = resbody_node.each_ancestor(:ensure).first)
-          return false unless (ensure_body = ensure_node.body)
+          return false unless (ensure_body = ensure_node.branch)
 
           ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
         end

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

@@ -72,7 +72,7 @@ module RuboCop
         def_node_matcher :method_definition, <<~PATTERN
           {
             (def %1 ...)
-            ({block numblock} (send _ :define_method (sym %1)) ...)
+            (any_block (send _ :define_method (sym %1)) ...)
           }
         PATTERN
 
@@ -108,7 +108,7 @@ module RuboCop
 
         def find_method_definition(node, method_name)
           node.each_ancestor.lazy.map do |ancestor|
-            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+            ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
           end.find(&:itself)

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

@@ -102,24 +102,18 @@ module RuboCop
             when :op_asgn
               process_binary_operator_assignment(node)
             when *ASSIGNMENT_TYPES
-              _, rhs_node = *node
-              process_assignment(node, rhs_node) if rhs_node
+              process_assignment(node, node.rhs) if node.rhs
             end
           end
 
           def process_multiple_assignment(masgn_node)
-            mlhs_node, mrhs_node = *masgn_node
-
-            mlhs_node.children.each_with_index do |lhs_node, index|
+            masgn_node.assignments.each_with_index do |lhs_node, index|
               next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
-              lhs_variable_name, = *lhs_node
-              rhs_node = mrhs_node.children[index]
-
-              if mrhs_node.array_type? && rhs_node
-                process_assignment(lhs_variable_name, rhs_node)
+              if masgn_node.rhs.array_type? && (rhs_node = masgn_node.rhs.children[index])
+                process_assignment(lhs_node, rhs_node)
               else
-                @local[lhs_variable_name] = true
+                @local[lhs_node.name] = true
               end
             end
 
@@ -127,33 +121,28 @@ module RuboCop
           end
 
           def process_logical_operator_assignment(asgn_node)
-            lhs_node, rhs_node = *asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+            return unless ASSIGNMENT_TYPES.include?(asgn_node.lhs.type)
 
-            process_assignment(lhs_node, rhs_node)
+            process_assignment(asgn_node.lhs, asgn_node.rhs)
 
             throw :skip_children
           end
 
           def process_binary_operator_assignment(op_asgn_node)
-            lhs_node, = *op_asgn_node
+            lhs_node = op_asgn_node.lhs
             return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
 
-            lhs_variable_name, = *lhs_node
-            @local[lhs_variable_name] = true
+            @local[lhs_node.name] = true
 
             throw :skip_children
           end
 
           def process_assignment(asgn_node, rhs_node)
-            lhs_variable_name, = *asgn_node
-
-            @local[lhs_variable_name] = if rhs_node.variable?
-                                          rhs_variable_name, = *rhs_node
-                                          @local[rhs_variable_name]
-                                        else
-                                          constructor?(rhs_node)
-                                        end
+            @local[asgn_node.name] = if rhs_node.variable?
+                                       @local[rhs_node.name]
+                                     else
+                                       constructor?(rhs_node)
+                                     end
           end
 
           def constructor?(node)