rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   end
+      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
+
+          expressions.each_cons(2) do |expression1, expression2|
+            next unless flow_expression?(expression1)
+
+            add_offense(expression2)
+          end
+        end
+
+        alias on_kwbegin on_begin
+
+        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)}
+             #redefinable_flow_method?
+             ...)
+          }
+        PATTERN
+
+        def flow_expression?(node)
+          return report_on_flow_command?(node) if flow_command?(node)
+
+          case node.type
+          when :begin, :kwbegin
+            expressions = *node
+            expressions.any? { |expr| flow_expression?(expr) }
+          when :if
+            check_if(node)
+          when :case, :case_match
+            check_case(node)
+          when :def
+            register_redefinition(node)
+          else
+            false
+          end
+        end
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch && flow_expression?(if_branch) && flow_expression?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless flow_expression?(else_branch)
+
+          branches = node.case_type? ? node.when_branches : node.in_pattern_branches
+
+          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
+end

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for loops that will have at most one iteration.
+      #
+      # A loop that can never reach the second iteration is a possible error in the code.
+      # In rare cases where only one iteration (or at most one iteration) is intended behavior,
+      # the code should be refactored to use `if` conditionals.
+      #
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
+      #
+      # `AllowedPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
+      # @example
+      #   # bad
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #     break
+      #   end
+      #
+      #   # good
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #   end
+      #
+      #   # bad
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         return true
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #   end
+      #
+      #   # good
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         item = item.next
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #
+      #     true
+      #   end
+      #
+      #   # bad
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       else
+      #         raise NotFoundError
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       end
+      #     end
+      #     raise NotFoundError
+      #   end
+      #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
+      class UnreachableLoop < Base
+        include AllowedPattern
+
+        MSG = 'This loop will have at most one iteration.'
+        CONTINUE_KEYWORDS = %i[next redo].freeze
+
+        def on_while(node)
+          check(node)
+        end
+        alias on_until on_while
+        alias on_while_post on_while
+        alias on_until_post on_while
+        alias on_for on_while
+
+        def on_block(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.any_block_type?
+
+          send_node = node.send_node
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
+        end
+
+        def check(node)
+          statements = statements(node)
+          break_statement = statements.find { |statement| break_statement?(statement) }
+          return unless break_statement
+
+          unless preceded_by_continue_statement?(break_statement) ||
+                 conditional_continue_keyword?(break_statement)
+            add_offense(node)
+          end
+        end
+
+        def statements(node)
+          body = node.body
+
+          if body.nil?
+            []
+          elsif body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        # @!method break_command?(node)
+        def_node_matcher :break_command?, <<~PATTERN
+          {
+            return break
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw :exit :exit! :abort}
+             ...)
+          }
+        PATTERN
+
+        def break_statement?(node)
+          return true if break_command?(node)
+
+          case node.type
+          when :begin, :kwbegin
+            statements = *node
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_statement)
+          when :if
+            check_if(node)
+          when :case, :case_match
+            check_case(node)
+          else
+            false
+          end
+        end
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch && break_statement?(if_branch) && break_statement?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless break_statement?(else_branch)
+
+          branches = if node.case_type?
+                       node.when_branches
+                     else
+                       node.in_pattern_branches
+                     end
+
+          branches.all? { |branch| branch.body && break_statement?(branch.body) }
+        end
+
+        def preceded_by_continue_statement?(break_statement)
+          break_statement.left_siblings.any? do |sibling|
+            # 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?
+          end
+        end
+
+        def conditional_continue_keyword?(break_statement)
+          or_node = break_statement.each_descendant(:or).to_a.last
+
+          or_node && CONTINUE_KEYWORDS.include?(or_node.rhs.type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unused block arguments.
+      #
+      # @example
+      #   # bad
+      #   do_something do |used, unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do |bar|
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |bar|
+      #     puts :baz
+      #   end
+      #
+      #   # good
+      #   do_something do |used, _unused|
+      #     puts used
+      #   end
+      #
+      #   do_something do
+      #     puts :foo
+      #   end
+      #
+      #   define_method(:foo) do |_bar|
+      #     puts :baz
+      #   end
+      #
+      # @example IgnoreEmptyBlocks: true (default)
+      #   # good
+      #   do_something { |unused| }
+      #
+      # @example IgnoreEmptyBlocks: false
+      #   # bad
+      #   do_something { |unused| }
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   do_something do |unused: 42|
+      #     foo
+      #   end
+      #
+      class UnusedBlockArgument < Base
+        include UnusedArgument
+        extend AutoCorrector
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          UnusedArgCorrector.correct(corrector, processed_source, node)
+        end
+
+        def check_argument(variable)
+          return if allowed_block?(variable) ||
+                    allowed_keyword_argument?(variable) ||
+                    used_block_local?(variable)
+
+          super
+        end
+
+        def used_block_local?(variable)
+          variable.explicit_block_local_variable? && !variable.assignments.empty?
+        end
+
+        def allowed_block?(variable)
+          !variable.block_argument? || (ignore_empty_blocks? && empty_block?(variable))
+        end
+
+        def allowed_keyword_argument?(variable)
+          variable.keyword_argument? && allow_unused_keyword_arguments?
+        end
+
+        def message(variable)
+          message = "Unused #{variable_type(variable)} - `#{variable.name}`."
+
+          if variable.explicit_block_local_variable?
+            message
+          else
+            augment_message(message, variable)
+          end
+        end
+
+        def augment_message(message, variable)
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:block_argument?)
+
+          augmentation = if scope.node.lambda?
+                           message_for_lambda(variable, all_arguments)
+                         else
+                           message_for_normal_block(variable, all_arguments)
+                         end
+
+          [message, augmentation].join(' ')
+        end
+
+        def variable_type(variable)
+          if variable.explicit_block_local_variable?
+            'block local variable'
+          else
+            'block argument'
+          end
+        end
+
+        def message_for_normal_block(variable, all_arguments)
+          if all_arguments.none?(&:referenced?) && !define_method_call?(variable)
+            if all_arguments.count > 1
+              "You can omit all the arguments if you don't care about them."
+            else
+              "You can omit the argument if you don't care about it."
+            end
+          else
+            message_for_underscore_prefix(variable)
+          end
+        end
+
+        def message_for_lambda(variable, all_arguments)
+          message = message_for_underscore_prefix(variable)
+
+          if all_arguments.none?(&:referenced?)
+            proc_message = 'Also consider using a proc without arguments ' \
+                           'instead of a lambda if you want it ' \
+                           "to accept any arguments but don't care about them."
+          end
+
+          [message, proc_message].compact.join(' ')
+        end
+
+        def message_for_underscore_prefix(variable)
+          "If it's necessary, use `_` or `_#{variable.name}` " \
+            "as an argument name to indicate that it won't be used."
+        end
+
+        def define_method_call?(variable)
+          call, = *variable.scope.node
+          _, method, = *call
+
+          method == :define_method
+        end
+
+        def empty_block?(variable)
+          _send, _args, body = *variable.scope.node
+
+          body.nil?
+        end
+
+        def allow_unused_keyword_arguments?
+          cop_config['AllowUnusedKeywordArguments']
+        end
+
+        def ignore_empty_blocks?
+          cop_config['IgnoreEmptyBlocks']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unused method arguments.
+      #
+      # @example
+      #   # bad
+      #   def some_method(used, unused, _unused_but_allowed)
+      #     puts used
+      #   end
+      #
+      #   # good
+      #   def some_method(used, _unused, _unused_but_allowed)
+      #     puts used
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: false (default)
+      #   # bad
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example AllowUnusedKeywordArguments: true
+      #   # good
+      #   def do_something(used, unused: 42)
+      #     used
+      #   end
+      #
+      # @example IgnoreEmptyMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #   end
+      #
+      # @example IgnoreEmptyMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: true (default)
+      #   # with default value of `NotImplementedExceptions: ['NotImplementedError']`
+      #
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     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)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   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 #allowed_exception_class? ...)
+           (send nil? :fail ...)}
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Style::ExplicitBlockArgument]
+        end
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          UnusedArgCorrector.correct(corrector, processed_source, node)
+        end
+
+        def check_argument(variable)
+          return unless variable.method_argument?
+          return if variable.keyword_argument? && cop_config['AllowUnusedKeywordArguments']
+          return if ignored_method?(variable.scope.node.body)
+
+          super
+        end
+
+        def ignored_method?(body)
+          (cop_config['IgnoreEmptyMethods'] && body.nil?) ||
+            (cop_config['IgnoreNotImplementedMethods'] && not_implemented?(body))
+        end
+
+        def message(variable)
+          message = +"Unused method argument - `#{variable.name}`."
+
+          unless variable.keyword_argument?
+            message << " If it's necessary, use `_` or `_#{variable.name}` " \
+                       "as an argument name to indicate that it won't be used. " \
+                       "If it's unnecessary, remove it."
+          end
+
+          scope = variable.scope
+          all_arguments = scope.variables.each_value.select(&:method_argument?)
+
+          if all_arguments.none?(&:referenced?)
+            message << " You can also write as `#{scope.name}(*)` " \
+                       'if you want the method to accept any arguments ' \
+                       "but don't care about them."
+          end
+
+          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
+end