rubocop 0.75.1

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
+      #
+      #   assigned but unused variable - foo
+      #
+      # Currently this cop has advanced logic that detects unreferenced
+      # reassignments and properly handles varied cases such as branch, loop,
+      # rescue, ensure, etc.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something(some_var)
+      #   end
+      class UselessAssignment < Cop
+        include NameSimilarity
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_for_unused_assignments(variable)
+          end
+        end
+
+        def check_for_unused_assignments(variable)
+          return if variable.should_be_unused?
+
+          variable.assignments.each do |assignment|
+            next if assignment.used?
+
+            message = message_for_useless_assignment(assignment)
+
+            location = if assignment.regexp_named_capture?
+                         assignment.node.children.first.source_range
+                       else
+                         assignment.node.loc.name
+                       end
+
+            add_offense(nil, location: location, message: message)
+          end
+        end
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, variable: variable.name) +
+            message_specification(assignment, variable).to_s
+        end
+
+        def message_specification(assignment, variable)
+          if assignment.multiple_assignment?
+            multiple_assignment_message(variable.name)
+          elsif assignment.operator_assignment?
+            operator_assignment_message(variable.scope, assignment)
+          else
+            similar_name_message(variable)
+          end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node
+                                  .equal?(return_value_node)
+
+          " Use `#{assignment.operator.sub(/=$/, '')}` " \
+          "instead of `#{assignment.operator}`."
+        end
+
+        def similar_name_message(variable)
+          similar_name = find_similar_name(variable.name, variable.scope)
+          " Did you mean `#{similar_name}`?" if similar_name
+        end
+
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.begin_type?
+            body_node.children.last
+          else
+            body_node
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            set << node.method_name if variable_like_method_invocation?(node)
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+
+          node.receiver.nil? && !node.arguments?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for comparison of something with itself.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x.top >= x.top
+      class UselessComparison < Cop
+        MSG = 'Comparison of something with itself detected.'
+        OPS = %w[== === != < > <= >= <=>].freeze
+
+        def_node_matcher :useless_comparison?,
+                         "(send $_match {:#{OPS.join(' :')}} $_match)"
+
+        def on_send(node)
+          return unless useless_comparison?(node)
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      #
+      # Note: This syntax is no longer valid on Ruby 2.6 or higher and
+      # this cop is going to be removed at some point the future.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   else
+      #     do_something_else # This will never be run.
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_errors
+      #   else
+      #     do_something_else
+      #   end
+      class UselessElseWithoutRescue < Cop
+        include ParserDiagnostic
+
+        MSG = '`else` without `rescue` is useless.'
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :useless_else
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for setter call to local variable as the final
+      # expression of a function definition.
+      #
+      # @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 < Cop
+        MSG = 'Useless setter call to local variable `%<variable>s`.'
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        def on_def(node)
+          return unless node.body
+
+          last_expr = last_expression(node.body)
+          return unless setter_call_to_local_variable?(last_expr)
+
+          tracker = MethodVariableTracker.new(node.body)
+          receiver, = *last_expr
+          variable_name, = *receiver
+          return unless tracker.contain_local_object?(variable_name)
+
+          add_offense(
+            receiver,
+            location: :name,
+            message: format(MSG, variable: receiver.loc.name.source)
+          )
+        end
+        alias on_defs on_def
+
+        private
+
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
+          [(send (lvar _) ...) setter_method?]
+        PATTERN
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
+        end
+
+        # This class tracks variable assignments in a method body
+        # and if a variable contains object passed as argument at the end of
+        # the method.
+        class MethodVariableTracker
+          def initialize(body_node)
+            @body_node = body_node
+            @local = nil
+          end
+
+          def contain_local_object?(variable_name)
+            return @local[variable_name] if @local
+
+            @local = {}
+
+            scan(@body_node) { |node| process_assignment_node(node) }
+
+            @local[variable_name]
+          end
+
+          def scan(node, &block)
+            catch(:skip_children) do
+              yield node
+
+              node.each_child_node do |child_node|
+                scan(child_node, &block)
+              end
+            end
+          end
+
+          def process_assignment_node(node)
+            case node.type
+            when :masgn
+              process_multiple_assignment(node)
+            when :or_asgn, :and_asgn
+              process_logical_operator_assignment(node)
+            when :op_asgn
+              process_binary_operator_assignment(node)
+            when *ASSIGNMENT_TYPES
+              _, rhs_node = *node
+              process_assignment(node, rhs_node) if rhs_node
+            end
+          end
+
+          def process_multiple_assignment(masgn_node)
+            mlhs_node, mrhs_node = *masgn_node
+
+            mlhs_node.children.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)
+              else
+                @local[lhs_variable_name] = true
+              end
+            end
+
+            throw :skip_children
+          end
+
+          def process_logical_operator_assignment(asgn_node)
+            lhs_node, rhs_node = *asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+            process_assignment(lhs_node, rhs_node)
+
+            throw :skip_children
+          end
+
+          def process_binary_operator_assignment(op_asgn_node)
+            lhs_node, = *op_asgn_node
+            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
+            lhs_variable_name, = *lhs_node
+            @local[lhs_variable_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
+          end
+
+          def constructor?(node)
+            return true if node.literal?
+            return false unless node.send_type?
+
+            node.method_name == :new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables, literals, and nonmutating
+      # methods used in void context.
+      #
+      # @example CheckForMethodsWithNoSideEffects: false (default)
+      #   # bad
+      #   def some_method
+      #     some_num * 10
+      #     do_something
+      #   end
+      #
+      #   def some_method(some_var)
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
+      #   def some_method(some_array)
+      #     some_array.sort
+      #     do_something(some_array)
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      #   def some_method(some_var)
+      #     do_something
+      #     some_var
+      #   end
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
+      class Void < Cop
+        OP_MSG = 'Operator `%<op>s` used in void context.'
+        VAR_MSG = 'Variable `%<var>s` used in void context.'
+        LIT_MSG = 'Literal `%<lit>s` used in void context.'
+        SELF_MSG = '`self` used in void context.'
+        DEFINED_MSG = '`%<defined>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
+          'Did you mean `#%<method>s!`?'
+
+        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
+        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
+        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
+        VOID_CONTEXT_TYPES = %i[def for block].freeze
+        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
+                                 delete_prefix delete_suffix downcase
+                                 encode flatten gsub lstrip map next reject
+                                 reverse rotate rstrip scrub select shuffle
+                                 slice sort sort_by squeeze strip sub succ
+                                 swapcase tr tr_s transform_values
+                                 unicode_normalize uniq upcase].freeze
+
+        def on_block(node)
+          return unless node.body && !node.body.begin_type?
+          return unless in_void_context?(node.body)
+
+          check_expression(node.body)
+        end
+
+        def on_begin(node)
+          check_begin(node)
+        end
+        alias on_kwbegin on_begin
+
+        private
+
+        def check_begin(node)
+          expressions = *node
+          expressions.pop unless in_void_context?(node)
+          expressions.each do |expr|
+            check_expression(expr)
+          end
+        end
+
+        def check_expression(expr)
+          check_void_op(expr)
+          check_literal(expr)
+          check_var(expr)
+          check_self(expr)
+          check_defined(expr)
+          return unless cop_config['CheckForMethodsWithNoSideEffects']
+
+          check_nonmutating(expr)
+        end
+
+        def check_void_op(node)
+          return unless node.send_type? && OPERATORS.include?(node.method_name)
+
+          add_offense(node,
+                      location: :selector,
+                      message: format(OP_MSG, op: node.method_name))
+        end
+
+        def check_var(node)
+          return unless node.variable? || node.const_type?
+
+          add_offense(node,
+                      location: :name,
+                      message: format(VAR_MSG, var: node.loc.name.source))
+        end
+
+        def check_literal(node)
+          return if !node.literal? || node.xstr_type?
+
+          add_offense(node, message: format(LIT_MSG, lit: node.source))
+        end
+
+        def check_self(node)
+          return unless node.self_type?
+
+          add_offense(node, message: SELF_MSG)
+        end
+
+        def check_defined(node)
+          return unless node.defined_type?
+
+          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+        end
+
+        def check_nonmutating(node)
+          unless node.send_type? &&
+                 NONMUTATING_METHODS.include?(node.method_name)
+            return
+          end
+
+          add_offense(node, message: format(NONMUTATING_MSG,
+                                            method: node.method_name))
+        end
+
+        def in_void_context?(node)
+          parent = node.parent
+
+          return false unless parent && parent.children.last == node
+
+          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
+        end
+      end
+    end
+  end
+end