rubocop 0.48.1 → 1.16.0

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

@@ -30,18 +30,15 @@ module RuboCop
       #     some_var = 1
       #     do_something(some_var)
       #   end
-      class UselessAssignment < Cop
-        include NameSimilarity
-        MSG = 'Useless assignment to variable - `%s`.'.freeze
+      class UselessAssignment < Base
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_for_unused_assignments(variable)
-          end
+          scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
         end
 
         def check_for_unused_assignments(variable)
@@ -58,15 +55,14 @@ module RuboCop
                          assignment.node.loc.name
                        end
 
-            add_offense(nil, location, message)
+            add_offense(location, message: message)
           end
         end
 
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          format(MSG, variable.name) +
-            message_specification(assignment, variable).to_s
+          format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
         end
 
         def message_specification(assignment, variable)
@@ -86,15 +82,15 @@ module RuboCop
 
         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)
+          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)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name, variable_like_names)
           " Did you mean `#{similar_name}`?" if similar_name
         end
 
@@ -111,10 +107,7 @@ module RuboCop
 
         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
+            set << node.method_name if variable_like_method_invocation?(node)
           end
 
           variable_names = scope.variables.each_value.map(&:name)
@@ -123,8 +116,8 @@ module RuboCop
 
         def variable_like_method_invocation?(node)
           return false unless node.send_type?
-          receiver, _method_name, *args = *node
-          receiver.nil? && args.empty?
+
+          node.receiver.nil? && !node.arguments?
         end
       end
     end

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

@@ -5,6 +5,9 @@ module RuboCop
     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
@@ -26,19 +29,15 @@ module RuboCop
       #   else
       #     do_something_else
       #   end
-      class UselessElseWithoutRescue < Cop
-        include ParserDiagnostic
-
-        MSG = '`else` without `rescue` is useless.'.freeze
+      class UselessElseWithoutRescue < Base
+        MSG = '`else` without `rescue` is useless.'
 
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :useless_else
-        end
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :useless_else
 
-        def alternative_message(_diagnostic)
-          MSG
+            add_offense(diagnostic.location, severity: diagnostic.level)
+          end
         end
       end
     end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for useless method definitions, specifically: empty constructors
+      # and methods just delegating to `super`.
+      #
+      # This cop is marked as unsafe as it can trigger false positives for cases when
+      # an empty constructor just overrides the parent constructor, which is bad anyway.
+      #
+      # @example
+      #   # bad
+      #   def initialize
+      #     super
+      #   end
+      #
+      #   def method
+      #     super
+      #   end
+      #
+      #   # good - with default arguments
+      #   def initialize(x = Object.new)
+      #     super
+      #   end
+      #
+      #   # good
+      #   def initialize
+      #     super
+      #     initialize_internals
+      #   end
+      #
+      #   def method(*args)
+      #     super(:extra_arg, *args)
+      #   end
+      #
+      class UselessMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Useless method definition detected.'
+
+        def on_def(node)
+          return if optional_args?(node)
+          return unless delegating?(node.body, node)
+
+          add_offense(node) { |corrector| corrector.remove(node) }
+        end
+        alias on_defs on_def
+
+        private
+
+        def optional_args?(node)
+          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
+        end
+
+        def delegating?(node, def_node)
+          if node&.zsuper_type?
+            true
+          elsif node&.super_type?
+            node.arguments.map(&:source) == def_node.arguments.map(&:source)
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,11 @@ module RuboCop
     module Lint
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
+      # Its auto-correction is marked as unsafe because return value will be changed.
+      #
+      # 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.
       #
       # @example
       #
@@ -24,27 +29,37 @@ module RuboCop
       #     x.attr = 5
       #     x
       #   end
-      class UselessSetterCall < Cop
-        include OnMethodDef
+      class UselessSetterCall < Base
+        extend AutoCorrector
 
-        MSG = 'Useless setter call to local variable `%s`.'.freeze
+        MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        private
-
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
+        def on_def(node)
+          return unless node.body
 
-          last_expr = last_expression(body)
+          last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(body)
+          tracker = MethodVariableTracker.new(node.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))
+          loc_name = receiver.loc.name
+
+          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
 
         def last_expression(body)
           expression = body.begin_type? ? body.children : body
@@ -52,13 +67,6 @@ module RuboCop
           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.
@@ -82,9 +90,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
 
@@ -124,6 +130,7 @@ module RuboCop
           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
@@ -132,6 +139,7 @@ module RuboCop
           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
 
@@ -152,8 +160,8 @@ module RuboCop
           def constructor?(node)
             return true if node.literal?
             return false unless node.send_type?
-            _receiver, method = *node
-            method == :new
+
+            node.method?(:new)
           end
         end
       end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+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
+      # (`1.times`).
+      #
+      # This cop is marked as unsafe as `times` returns its receiver, which
+      # is *usually* OK, but might change behavior.
+      #
+      # @example
+      #   # bad
+      #   -5.times { do_something }
+      #   0.times { do_something }
+      #   1.times { do_something  }
+      #   1.times { |i| do_something(i) }
+      #
+      #   # good
+      #   do_something
+      #   do_something(1)
+      class UselessTimes < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        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
+
+        def on_send(node)
+          return unless (count, proc_name = times_call?(node))
+          return if count > 1
+
+          # Get the block node if applicable
+          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
+          end
+        end
+
+        private
+
+        def never_process?(count, node)
+          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))
+        end
+
+        def autocorrect_block_pass(corrector, node, proc_name)
+          corrector.replace(node, proc_name)
+        end
+
+        def autocorrect_block(corrector, node)
+          block_arg = block_arg(node)
+          return if block_reassigns_arg?(node, block_arg)
+
+          source = node.body.source
+          source.gsub!(/\b#{block_arg}\b/, '1') if block_arg
+
+          corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
+        end
+
+        def fix_indentation(source, range)
+          # Cleanup indentation in a multiline block
+          source_lines = source.split("\n")
+
+          source_lines[1..-1].each do |line|
+            next if line.empty?
+
+            line[range] = ''
+          end
+          source_lines.join("\n")
+        end
+
+        def own_line?(node)
+          # If there is anything else on the line other than whitespace,
+          # don't try to autocorrect
+          processed_source.buffer.source_line(node.loc.line)[0...node.loc.column] !~ /\S/
+        end
+      end
+    end
+  end
+end

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

@@ -3,104 +3,136 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for operators, variables and literals used
-      # in void context.
-      #
-      # @example
+      # 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
       #
-      # @example
-      #
-      #   # bad
-      #
-      #   def some_method
+      #   def some_method(some_var)
       #     some_var
       #     do_something
       #   end
       #
-      # @example
+      # @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
       #
-      # @example
-      #
-      #   # good
-      #
-      #   def some_method
+      #   def some_method(some_var)
       #     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)
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
+      class Void < Base
+        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 merge 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_kwbegin(node)
+        def on_begin(node)
           check_begin(node)
         end
+        alias on_kwbegin on_begin
 
         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
+          expressions.pop unless in_void_context?(node)
+          expressions.each { |expr| check_expression(expr) }
         end
 
-        def check_for_void_op(node)
-          return unless node.send_type? && node.loc.selector
+        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
 
-          op = node.loc.selector.source
+        def check_void_op(node)
+          return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
+          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
         end
 
-        def check_for_var(node)
+        def check_var(node)
           return unless node.variable? || node.const_type?
-          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+
+          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
         end
 
-        def check_for_literal(node)
-          return if !node.literal? || node.xstr_type?
+        def check_literal(node)
+          return if !node.literal? || node.xstr_type? || node.range_type?
 
-          add_offense(node, :expression, format(LIT_MSG, node.source))
+          add_offense(node, message: format(LIT_MSG, lit: node.source))
         end
 
-        def check_for_self(node)
+        def check_self(node)
           return unless node.self_type?
 
-          add_offense(node, :expression, SELF_MSG)
+          add_offense(node, message: SELF_MSG)
         end
 
-        def check_for_defined(node)
+        def check_defined(node)
           return unless node.defined_type?
 
-          add_offense(node, :expression, format(DEFINED_MSG, node.source))
+          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+        end
+
+        def check_nonmutating(node)
+          return unless node.send_type? && NONMUTATING_METHODS.include?(node.method_name)
+
+          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