rubocop 1.67.0 → 1.79.1

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_default_value_argument.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for usage of method `fetch` or `Array.new` with default value argument
+      # and block. In such cases, block will always be used as default value.
+      #
+      # This cop emulates Ruby warning "block supersedes default value argument" which
+      # applies to `Array.new`, `Array#fetch`, `Hash#fetch`, `ENV.fetch` and
+      # `Thread#fetch`.
+      #
+      # A `fetch` call without a receiver is considered a custom method and does not register
+      # an offense.
+      #
+      # @safety
+      #   This cop is unsafe because the receiver could have nonstandard implementation
+      #   of `fetch`, or be a class other than the one listed above.
+      #
+      #   It is also unsafe because default value argument could have side effects:
+      #
+      #   [source,ruby]
+      #   ----
+      #   def x(a) = puts "side effect"
+      #   Array.new(5, x(1)) { 2 }
+      #   ----
+      #
+      #   so removing it would change behavior.
+      #
+      # @example
+      #   # bad
+      #   x.fetch(key, default_value) { block_value }
+      #   Array.new(size, default_value) { block_value }
+      #
+      #   # good
+      #   x.fetch(key) { block_value }
+      #   Array.new(size) { block_value }
+      #
+      #   # also good - in case default value argument is desired instead
+      #   x.fetch(key, default_value)
+      #   Array.new(size, default_value)
+      #
+      #   # good - keyword arguments aren't registered as offenses
+      #   x.fetch(key, keyword: :arg) { block_value }
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class UselessDefaultValueArgument < Base
+        include AllowedReceivers
+        extend AutoCorrector
+
+        MSG = 'Block supersedes default value argument.'
+
+        RESTRICT_ON_SEND = %i[fetch new].freeze
+
+        # @!method default_value_argument_and_block(node)
+        def_node_matcher :default_value_argument_and_block, <<~PATTERN
+          (any_block
+            {
+              (call !nil? :fetch $_key $_default_value)
+              (send (const _ :Array) :new $_size $_default_value)
+            }
+            _args
+            _block_body)
+        PATTERN
+
+        def on_send(node)
+          unless (prev_arg_node, default_value_node = default_value_argument_and_block(node.parent))
+            return
+          end
+          return if allowed_receiver?(node.receiver)
+          return if hash_without_braces?(default_value_node)
+
+          add_offense(default_value_node) do |corrector|
+            corrector.remove(prev_arg_node.source_range.end.join(default_value_node.source_range))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        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

@@ -31,11 +31,12 @@ module RuboCop
       #
       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?, '(send (send nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
 
         # @!method useless_abbreviated_assignment?(node)
         def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
@@ -50,6 +51,7 @@ module RuboCop
             corrector.replace(node, variable)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
           return unless useless_abbreviated_assignment?(node)

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless OR (`||` and `or`) expressions.
+      #
+      # Some methods always return a truthy value, even when called
+      # on `nil` (e.g. `nil.to_i` evaluates to `0`). Therefore, OR expressions
+      # appended after these methods will never evaluate.
+      #
+      # @example
+      #
+      #   # bad
+      #   x.to_a || fallback
+      #   x.to_c || fallback
+      #   x.to_d || fallback
+      #   x.to_i || fallback
+      #   x.to_f || fallback
+      #   x.to_h || fallback
+      #   x.to_r || fallback
+      #   x.to_s || fallback
+      #   x.to_sym || fallback
+      #   x.intern || fallback
+      #   x.inspect || fallback
+      #   x.hash || fallback
+      #   x.object_id || fallback
+      #   x.__id__ || fallback
+      #
+      #   x.to_s or fallback
+      #
+      #   # good - if fallback is same as return value of method called on nil
+      #   x.to_a # nil.to_a returns []
+      #   x.to_c # nil.to_c returns (0+0i)
+      #   x.to_d # nil.to_d returns 0.0
+      #   x.to_i # nil.to_i returns 0
+      #   x.to_f # nil.to_f returns 0.0
+      #   x.to_h # nil.to_h returns {}
+      #   x.to_r # nil.to_r returns (0/1)
+      #   x.to_s # nil.to_s returns ''
+      #   x.to_sym # nil.to_sym raises an error
+      #   x.intern # nil.intern raises an error
+      #   x.inspect # nil.inspect returns "nil"
+      #   x.hash # nil.hash returns an Integer
+      #   x.object_id # nil.object_id returns an Integer
+      #   x.__id__ # nil.object_id returns an Integer
+      #
+      #   # good - if the intention is not to call the method on nil
+      #   x&.to_a || fallback
+      #   x&.to_c || fallback
+      #   x&.to_d || fallback
+      #   x&.to_i || fallback
+      #   x&.to_f || fallback
+      #   x&.to_h || fallback
+      #   x&.to_r || fallback
+      #   x&.to_s || fallback
+      #   x&.to_sym || fallback
+      #   x&.intern || fallback
+      #   x&.inspect || fallback
+      #   x&.hash || fallback
+      #   x&.object_id || fallback
+      #   x&.__id__ || fallback
+      #
+      #   x&.to_s or fallback
+      #
+      class UselessOr < Base
+        MSG = '`%<rhs>s` will never evaluate because `%<lhs>s` always returns a truthy value.'
+
+        TRUTHY_RETURN_VALUE_METHODS = Set[:to_a, :to_c, :to_d, :to_i, :to_f, :to_h, :to_r,
+                                          :to_s, :to_sym, :intern, :inspect, :hash, :object_id,
+                                          :__id__].freeze
+
+        # @!method truthy_return_value_method?(node)
+        def_node_matcher :truthy_return_value_method?, <<~PATTERN
+          (send _ %TRUTHY_RETURN_VALUE_METHODS)
+        PATTERN
+
+        def on_or(node)
+          if truthy_return_value_method?(node.lhs)
+            report_offense(node, node.lhs)
+          elsif truthy_return_value_method?(node.rhs)
+            parent = node.parent
+            parent = parent.parent if parent&.begin_type?
+
+            report_offense(parent, node.rhs) if parent&.or_type?
+          end
+        end
+
+        private
+
+        def report_offense(or_node, truthy_node)
+          add_offense(or_node.loc.operator.join(or_node.rhs.source_range),
+                      message: format(MSG, lhs: truthy_node.source, rhs: or_node.rhs.source))
+        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
 
@@ -89,7 +89,7 @@ module RuboCop
         private
 
         def inspect_def(node, def_node)
-          return if allowed_arguments(def_node.arguments)
+          return if allowed_arguments?(def_node.arguments)
 
           add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
         end
@@ -101,21 +101,21 @@ module RuboCop
           definition = find_method_definition(node, method_name)
 
           return unless definition
-          return if allowed_arguments(definition.arguments)
+          return if allowed_arguments?(definition.arguments)
 
           add_offense(node, message: format(MSG, method_name: method_name))
         end
 
         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)
         end
 
         # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
-        def allowed_arguments(arguments)
+        def allowed_arguments?(arguments)
           return false if arguments.empty?
 
           arguments.each_child_node(:restarg).any? &&

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)

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