rbhint 0.8.5.rc1

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for underscore-prefixed variables that are actually
+      # used.
+      #
+      # Since block keyword arguments cannot be arbitrarily named at call
+      # sites, the `AllowKeywordBlockArguments` will allow use of underscore-
+      # prefixed block keyword arguments.
+      #
+      # @example AllowKeywordBlockArguments: false (default)
+      #
+      #   # bad
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something(_num)
+      #   end
+      #
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |num|
+      #     do_something(num)
+      #   end
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
+      #
+      # @example AllowKeywordBlockArguments: true
+      #
+      #   # good
+      #
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
+      #
+      class UnderscorePrefixedVariableName < Cop
+        MSG = 'Do not use prefix `_` for a variable that is used.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_variable(variable)
+          end
+        end
+
+        def check_variable(variable)
+          return unless variable.should_be_unused?
+          return if variable.references.none?(&:explicit?)
+          return if allowed_keyword_block_argument?(variable)
+
+          node = variable.declaration_node
+
+          location = if node.match_with_lvasgn_type?
+                       node.children.first.source_range
+                     else
+                       node.loc.name
+                     end
+
+          add_offense(nil, location: location)
+        end
+
+        private
+
+        def allowed_keyword_block_argument?(variable)
+          variable.block_argument? &&
+            variable.keyword_argument? &&
+            cop_config['AllowKeywordBlockArguments']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for using Fixnum or Bignum constant.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   1.is_a?(Fixnum)
+      #   1.is_a?(Bignum)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   1.is_a?(Integer)
+      class UnifiedInteger < Cop
+        MSG = 'Use `Integer` instead of `%<klass>s`.'
+
+        def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
+          (:const {nil? (:cbase)} ${:Fixnum :Bignum})
+        PATTERN
+
+        def on_const(node)
+          klass = fixnum_or_bignum_const(node)
+
+          return unless klass
+
+          add_offense(node, message: format(MSG, klass: klass))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.name, 'Integer')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop 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
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
+      class UnreachableCode < Cop
+        MSG = 'Unreachable code detected.'
+
+        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_node_matcher :flow_command?, <<~PATTERN
+          {
+            return next break retry redo
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw :exit :exit! :abort}
+             ...)
+          }
+        PATTERN
+
+        def flow_expression?(node)
+          return true 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
+            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 &&
+            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)
+
+          node.when_branches.all? do |branch|
+            branch.body && flow_expression?(branch.body)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop 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 < Cop
+        include UnusedArgument
+
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
+        private
+
+        def check_argument(variable)
+          return if allowed_block?(variable) ||
+                    allowed_keyword_argument?(variable)
+
+          super
+        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,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop 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)
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      class UnusedMethodArgument < Cop
+        include UnusedArgument
+
+        def_node_matcher :not_implemented?, <<~PATTERN
+          {(send nil? :raise (const nil? :NotImplementedError))
+           (send nil? :fail ...)}
+        PATTERN
+
+        def autocorrect(node)
+          UnusedArgCorrector.correct(processed_source, node)
+        end
+
+        private
+
+        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."
+          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
+      end
+    end
+  end
+end