rubbycop 0.49.0

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 - `%s`.'.freeze
+
+        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, message)
+          end
+        end
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, 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|
+            if variable_like_method_invocation?(node)
+              _receiver, method_name, = *node
+              set << method_name
+            end
+          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?
+          receiver, _method_name, *args = *node
+          receiver.nil? && args.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.'.freeze
+        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, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for useless `else` in `begin..end` without `rescue`.
+      #
+      # @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.'.freeze
+
+        private
+
+        def relevant_diagnostic?(diagnostic)
+          diagnostic.reason == :useless_else
+        end
+
+        def alternative_message(_diagnostic)
+          MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        include OnMethodDef
+
+        MSG = 'Useless setter call to local variable `%s`.'.freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+
+        private
+
+        def on_method_def(_node, _method_name, _args, body)
+          return unless body
+
+          last_expr = last_expression(body)
+          return unless setter_call_to_local_variable?(last_expr)
+
+          tracker = MethodVariableTracker.new(body)
+          receiver, = *last_expr
+          variable_name, = *receiver
+          return unless tracker.contain_local_object?(variable_name)
+
+          add_offense(receiver, :name, format(MSG, receiver.loc.name.source))
+        end
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
+        end
+
+        def setter_call_to_local_variable?(node)
+          return unless node && node.send_type?
+          receiver, method, _args = *node
+          return unless receiver && receiver.lvar_type?
+          method =~ /(?:\w|\[\])=$/
+        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?
+            _receiver, method = *node
+            method == :new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for operators, variables and literals used
+      # in void context.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_num * 10
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #     some_var
+      #   end
+      class Void < Cop
+        OP_MSG = 'Operator `%s` used in void context.'.freeze
+        VAR_MSG = 'Variable `%s` used in void context.'.freeze
+        LIT_MSG = 'Literal `%s` used in void context.'.freeze
+        SELF_MSG = '`self` used in void context.'.freeze
+        DEFINED_MSG = '`%s` used in void context.'.freeze
+
+        OPS = %w[* / % + - == === != < > <= >= <=>].freeze
+
+        def on_begin(node)
+          check_begin(node)
+        end
+
+        def on_kwbegin(node)
+          check_begin(node)
+        end
+
+        private
+
+        def check_begin(node)
+          expressions = *node
+
+          expressions.drop_last(1).each do |expr|
+            check_for_void_op(expr)
+            check_for_literal(expr)
+            check_for_var(expr)
+            check_for_self(expr)
+            check_for_defined(expr)
+          end
+        end
+
+        def check_for_void_op(node)
+          return unless node.send_type? && node.loc.selector
+
+          op = node.loc.selector.source
+
+          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
+        end
+
+        def check_for_var(node)
+          return unless node.variable? || node.const_type?
+          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+        end
+
+        def check_for_literal(node)
+          return if !node.literal? || node.xstr_type?
+
+          add_offense(node, :expression, format(LIT_MSG, node.source))
+        end
+
+        def check_for_self(node)
+          return unless node.self_type?
+
+          add_offense(node, :expression, SELF_MSG)
+        end
+
+        def check_for_defined(node)
+          return unless node.defined_type?
+
+          add_offense(node, :expression, format(DEFINED_MSG, node.source))
+        end
+      end
+    end
+  end
+end