rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless ``rescue``s, which only reraise rescued exceptions.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     do_something
+      #   rescue => e
+      #     raise # or 'raise e', or 'raise $!', or 'raise $ERROR_INFO'
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_cleanup
+      #     raise
+      #   end
+      #
+      #   # bad (latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     # noop
+      #   rescue
+      #     raise
+      #   end
+      #
+      #   # good (not the latest rescue)
+      #   def foo
+      #     do_something
+      #   rescue ArgumentError
+      #     raise
+      #   rescue
+      #     # noop
+      #   end
+      #
+      class UselessRescue < Base
+        MSG = 'Useless `rescue` detected.'
+
+        def on_rescue(node)
+          resbody_node = node.resbody_branches.last
+          add_offense(resbody_node) if only_reraising?(resbody_node)
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def only_reraising?(resbody_node)
+          return false if use_exception_variable_in_ensure?(resbody_node)
+
+          body = resbody_node.body
+
+          return false if body.nil? || !body.send_type? || !body.method?(:raise) || body.receiver
+          return true unless body.arguments?
+          return false if body.arguments.size > 1
+
+          exception_name = body.first_argument.source
+
+          exception_objects(resbody_node).include?(exception_name)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        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.branch)
+
+          ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
+        end
+
+        def exception_objects(resbody_node)
+          [resbody_node.exception_variable&.source, '$!', '$ERROR_INFO']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for `ruby2_keywords` calls for methods that do not need it.
+      #
+      # `ruby2_keywords` should only be called on methods that accept an argument splat
+      # (`\*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
+      # a keyword splat (`**kwargs`).
+      #
+      # @example
+      #   # good (splat argument without keyword arguments)
+      #   ruby2_keywords def foo(*args); end
+      #
+      #   # bad (no arguments)
+      #   ruby2_keywords def foo; end
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (positional argument)
+      #   ruby2_keywords def foo(arg); end
+      #
+      #   # good
+      #   def foo(arg); end
+      #
+      #   # bad (double splatted argument)
+      #   ruby2_keywords def foo(**args); end
+      #
+      #   # good
+      #   def foo(**args); end
+      #
+      #   # bad (keyword arguments)
+      #   ruby2_keywords def foo(i:, j:); end
+      #
+      #   # good
+      #   def foo(i:, j:); end
+      #
+      #   # bad (splat argument with keyword arguments)
+      #   ruby2_keywords def foo(*args, i:, j:); end
+      #
+      #   # good
+      #   def foo(*args, i:, j:); end
+      #
+      #   # bad (splat argument with double splat)
+      #   ruby2_keywords def foo(*args, **kwargs); end
+      #
+      #   # good
+      #   def foo(*args, **kwargs); end
+      #
+      #   # bad (ruby2_keywords given a symbol)
+      #   def foo; end
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   def foo; end
+      #
+      #   # bad (ruby2_keywords with dynamic method)
+      #   define_method(:foo) { |arg| }
+      #   ruby2_keywords :foo
+      #
+      #   # good
+      #   define_method(:foo) { |arg| }
+      #
+      class UselessRuby2Keywords < Base
+        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
+
+        # Looks for statically or dynamically defined methods with a given name
+        # @!method method_definition(node, method_name)
+        def_node_matcher :method_definition, <<~PATTERN
+          {
+            (def %1 ...)
+            (any_block (send _ :define_method (sym %1)) ...)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (first_argument = node.first_argument)
+
+          if first_argument.def_type?
+            inspect_def(node, first_argument)
+          elsif node.first_argument.sym_type?
+            inspect_sym(node, first_argument)
+          end
+        end
+
+        private
+
+        def inspect_def(node, def_node)
+          return if allowed_arguments?(def_node.arguments)
+
+          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
+        end
+
+        def inspect_sym(node, sym_node)
+          return unless node.parent
+
+          method_name = sym_node.value
+          definition = find_method_definition(node, method_name)
+
+          return unless definition
+          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, :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)
+          return false if arguments.empty?
+
+          arguments.each_child_node(:restarg).any? &&
+            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
+        end
+      end
+    end
+  end
+end

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

@@ -3,32 +3,34 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for setter call to local variable as the final
+      # Checks for setter call to local variable as the final
       # expression of a function definition.
       #
-      # NOTE: There are edge cases in which the local variable references a
-      # value that is also accessible outside the local scope. This is not
-      # detected by the cop, and it can yield a false positive.
+      # @safety
+      #   There are edge cases in which the local variable references a
+      #   value that is also accessible outside the local scope. This is not
+      #   detected by the cop, and it can yield a false positive.
+      #
+      #   As well, autocorrection is unsafe because the method's
+      #   return value will be changed.
       #
       # @example
       #
       #   # bad
-      #
       #   def something
       #     x = Something.new
       #     x.attr = 5
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def something
       #     x = Something.new
       #     x.attr = 5
       #     x
       #   end
       class UselessSetterCall < Base
+        extend AutoCorrector
+
         MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
@@ -45,12 +47,15 @@ module RuboCop
 
           loc_name = receiver.loc.name
 
-          add_offense(loc_name, message: format(MSG, variable: loc_name.source))
+          add_offense(loc_name, message: format(MSG, variable: loc_name.source)) do |corrector|
+            corrector.insert_after(last_expr, "\n#{indent(last_expr)}#{loc_name.source}")
+          end
         end
         alias on_defs on_def
 
         private
 
+        # @!method setter_call_to_local_variable?(node)
         def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
           [(send (lvar _) ...) setter_method?]
         PATTERN
@@ -84,9 +89,7 @@ module RuboCop
             catch(:skip_children) do
               yield node
 
-              node.each_child_node do |child_node|
-                scan(child_node, &block)
-              end
+              node.each_child_node { |child_node| scan(child_node, &block) }
             end
           end
 
@@ -99,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
 
@@ -124,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/useless_times.rb

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of `Integer#times` that will never yield
-      # (when the integer <= 0) or that will only ever yield once
+      # Checks for uses of `Integer#times` that will never yield
+      # (when the integer ``<= 0``) or that will only ever yield once
       # (`1.times`).
       #
-      # This cop is marked as unsafe as `times` returns its receiver, which
-      # is *usually* OK, but might change behavior.
+      # @safety
+      #   This cop is unsafe as `times` returns its receiver, which is
+      #   *usually* OK, but might change behavior.
       #
       # @example
       #   # bad
@@ -27,14 +28,17 @@ module RuboCop
         MSG = 'Useless call to `%<count>i.times` detected.'
         RESTRICT_ON_SEND = %i[times].freeze
 
+        # @!method times_call?(node)
         def_node_matcher :times_call?, <<~PATTERN
           (send (int $_) :times (block-pass (sym $_))?)
         PATTERN
 
+        # @!method block_arg(node)
         def_node_matcher :block_arg, <<~PATTERN
           (block _ (args (arg $_)) ...)
         PATTERN
 
+        # @!method block_reassigns_arg?(node)
         def_node_search :block_reassigns_arg?, <<~PATTERN
           (lvasgn %)
         PATTERN
@@ -47,26 +51,30 @@ module RuboCop
           node = node.block_node if node.block_literal?
 
           add_offense(node, message: format(MSG, count: count)) do |corrector|
-            next unless own_line?(node)
-
-            if never_process?(count, node)
-              remove_node(corrector, node)
-            elsif !proc_name.empty?
-              autocorrect_block_pass(corrector, node, proc_name)
-            else
-              autocorrect_block(corrector, node)
-            end
+            next if !own_line?(node) || node.parent&.send_type?
+
+            autocorrect(corrector, count, node, proc_name)
           end
         end
 
         private
 
+        def autocorrect(corrector, count, node, proc_name)
+          if never_process?(count, node)
+            remove_node(corrector, node)
+          elsif !proc_name.empty?
+            autocorrect_block_pass(corrector, node, proc_name)
+          elsif node.block_type?
+            autocorrect_block(corrector, node)
+          end
+        end
+
         def never_process?(count, node)
-          count < 1 || node.block_type? && node.body.nil?
+          count < 1 || (node.block_type? && node.body.nil?)
         end
 
         def remove_node(corrector, node)
-          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+          corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
         end
 
         def autocorrect_block_pass(corrector, node, proc_name)
@@ -78,7 +86,7 @@ module RuboCop
           return if block_reassigns_arg?(node, block_arg)
 
           source = node.body.source
-          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+          source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
 
           corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
         end
@@ -87,7 +95,7 @@ module RuboCop
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")
 
-          source_lines[1..-1].each do |line|
+          source_lines[1..].each do |line|
             next if line.empty?
 
             line[range] = ''

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