rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for shadowed arguments.
+      #
+      # This cop has `IgnoreImplicitReferences` configuration option.
+      # It means argument shadowing is used in order to pass parameters
+      # to zero arity `super` when `IgnoreImplicitReferences` is `true`.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something do |foo|
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   do_something do |foo|
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     puts foo
+      #   end
+      #
+      # @example IgnoreImplicitReferences: false (default)
+      #
+      #   # bad
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      # @example IgnoreImplicitReferences: true
+      #
+      #   # good
+      #   def do_something(foo)
+      #     foo = 42
+      #     super
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = super
+      #     bar
+      #   end
+      #
+      class ShadowedArgument < Cop
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
+              'before it was used.'
+
+        def_node_search :uses_var?, '(lvar %)'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(argument)
+          return unless argument.method_argument? || argument.block_argument?
+          # Block local variables, i.e., variables declared after ; inside
+          # |...| aren't really arguments.
+          return if argument.explicit_block_local_variable?
+
+          shadowing_assignment(argument) do |node|
+            message = format(MSG, argument: argument.name)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def shadowing_assignment(argument)
+          return unless argument.referenced?
+
+          assignment_without_argument_usage(argument) do |node, location_known|
+            assignment_without_usage_pos = node.source_range.begin_pos
+
+            references = argument_references(argument)
+
+            # If argument was referenced before it was reassigned
+            # then it's not shadowed
+            next if references.any? do |reference|
+              next true if !reference.explicit? && ignore_implicit_references?
+
+              reference_pos(reference.node) <= assignment_without_usage_pos
+            end
+
+            yield location_known ? node : argument.declaration_node
+          end
+        end
+
+        # Find the first argument assignment, which doesn't reference the
+        # argument at the rhs. If the assignment occurs inside a branch or
+        # block, it is impossible to tell whether it's executed, so precise
+        # shadowing location is not known.
+        #
+        def assignment_without_argument_usage(argument)
+          argument.assignments.reduce(true) do |location_known, assignment|
+            assignment_node = assignment.meta_assignment_node || assignment.node
+
+            # Shorthand assignments always use their arguments
+            next false if assignment_node.shorthand_asgn?
+
+            node_within_block_or_conditional =
+              node_within_block_or_conditional?(assignment_node.parent,
+                                                argument.scope.node)
+
+            unless uses_var?(assignment_node, argument.name)
+              # It's impossible to decide whether a branch or block is executed,
+              # so the precise reassignment location is undecidable.
+              next false if node_within_block_or_conditional
+
+              yield(assignment.node, location_known)
+              break
+            end
+
+            location_known
+          end
+        end
+
+        def reference_pos(node)
+          node = node.parent.masgn_type? ? node.parent : node
+
+          node.source_range.begin_pos
+        end
+
+        # Check whether the given node is nested into block or conditional.
+        #
+        def node_within_block_or_conditional?(node, stop_search_node)
+          return false if node == stop_search_node
+
+          node.conditional? || node.block_type? ||
+            node_within_block_or_conditional?(node.parent, stop_search_node)
+        end
+
+        # Get argument references without assignments' references
+        #
+        def argument_references(argument)
+          assignment_references = argument
+                                  .assignments
+                                  .flat_map(&:references)
+                                  .map(&:source_range)
+
+          argument.references.reject do |ref|
+            next false unless ref.explicit?
+
+            assignment_references.include?(ref.node.source_range)
+          end
+        end
+
+        def ignore_implicit_references?
+          cop_config['IgnoreImplicitReferences']
+        end
+      end
+    end
+  end
+end

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

@@ -45,17 +45,15 @@ module RuboCop
       #
       class ShadowedException < Cop
         include RescueNode
+        include RangeHelp
 
-        MSG = 'Do not shadow rescued Exceptions.'.freeze
+        MSG = 'Do not shadow rescued Exceptions.'
 
         def on_rescue(node)
           return if rescue_modifier?(node)
-          _body, *rescues, _else = *node
-          rescued_groups = rescues.each_with_object([]) do |group, exceptions|
-            rescue_group, = *group
 
-            exceptions << evaluate_exceptions(rescue_group)
-          end
+          _body, *rescues, _else = *node
+          rescued_groups = rescued_groups_for(rescues)
 
           rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
             contains_multiple_levels_of_exceptions?(group)
@@ -70,25 +68,21 @@ module RuboCop
         private
 
         def offense_range(rescues)
-          first_rescue = rescues.first
-          last_rescue = rescues.last
-          last_exceptions, = *last_rescue
-          # last_rescue clause may not specify exception class
-          end_pos = if last_exceptions
-                      last_exceptions.loc.expression.end_pos
-                    else
-                      last_rescue.loc.keyword.end_pos
-                    end
-
-          range_between(first_rescue.loc.expression.begin_pos, end_pos)
+          shadowing_rescue = find_shadowing_rescue(rescues)
+          expression = shadowing_rescue.loc.expression
+          range_between(expression.begin_pos, expression.end_pos)
         end
 
-        def contains_multiple_levels_of_exceptions?(group)
-          if group.size > 1 && group.include?(Exception)
-            # Treat `Exception` as the highest level exception unless `nil` was
-            # also rescued
-            return !(group.size == 2 && group.include?(NilClass))
+        def rescued_groups_for(rescues)
+          rescues.map do |group|
+            rescue_group, = *group
+            evaluate_exceptions(rescue_group)
           end
+        end
+
+        def contains_multiple_levels_of_exceptions?(group)
+          # Always treat `Exception` as the highest level exception.
+          return true if group.size > 1 && group.include?(Exception)
 
           group.combination(2).any? do |a, b|
             compare_exceptions(a, b)
@@ -113,12 +107,25 @@ module RuboCop
           error && error.ancestors[1] == SystemCallError
         end
 
+        def silence_warnings
+          # Replaces Kernel::silence_warnings since it hides any warnings,
+          # including the RuboCop ones
+          old_verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+
         def evaluate_exceptions(rescue_group)
           if rescue_group
             rescued_exceptions = rescued_exceptions(rescue_group)
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                converted << Kernel.const_get(exception)
+                silence_warnings do
+                  # Avoid printing deprecation warnings about constants
+                  converted << Kernel.const_get(exception)
+                end
               rescue NameError
                 converted << nil
               end
@@ -150,9 +157,21 @@ module RuboCop
           klasses = *rescue_group
           klasses.map do |klass|
             next unless klass.const_type?
+
             klass.source
           end.compact
         end
+
+        def find_shadowing_rescue(rescues)
+          rescued_groups = rescued_groups_for(rescues)
+          rescued_groups.zip(rescues).each do |group, res|
+            return res if contains_multiple_levels_of_exceptions?(group)
+          end
+
+          rescued_groups.each_cons(2).with_index do |group_pair, i|
+            return rescues[i] unless sorted?(group_pair)
+          end
+        end
       end
     end
   end

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

@@ -32,7 +32,7 @@ module RuboCop
       #     end
       #   end
       class ShadowingOuterLocalVariable < Cop
-        MSG = 'Shadowing outer local variable - `%s`.'.freeze
+        MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -44,7 +44,7 @@ module RuboCop
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
 
-          message = format(MSG, variable.name)
+          message = format(MSG, variable: variable.name)
           add_offense(variable.declaration_node, message: message)
         end
       end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks unexpected overrides of the `Struct` built-in methods
+      # via `Struct.new`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Struct.new(:members, :clone, :count)
+      #   b = Bad.new([], true, 1)
+      #   b.members #=> [] (overriding `Struct#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.count #=> 1 (overriding `Enumerable#count`)
+      #
+      #   # good
+      #   Good = Struct.new(:id, :name)
+      #   g = Good.new(1, "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<struct Good id=1, name="foo">
+      #   g.count #=> 2
+      #
+      class StructNewOverride < Cop
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
+              ' and it may be unexpected.'
+
+        STRUCT_METHOD_NAMES = Struct.instance_methods
+        STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        def_node_matcher :struct_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless struct_new(node) do
+            node.arguments.each_with_index do |arg, index|
+              # Ignore if the first argument is a class name
+              next if index.zero? && arg.str_type?
+
+              # Ignore if the argument is not a member name
+              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+
+              member_name = arg.value
+
+              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+              message = format(MSG, member_name: member_name.inspect,
+                                    method_name: member_name.to_s)
+              add_offense(arg, message: message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `rescue` blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      class SuppressedException < Cop
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          return if node.body
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def comment_between_rescue_and_end?(node)
+          end_line = nil
+          node.each_ancestor(:kwbegin, :def, :defs, :block) do |ancestor|
+            end_line = ancestor.loc.end.line
+            break
+          end
+          return false unless end_line
+
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -3,50 +3,34 @@
 module RuboCop
   module Cop
     module Lint
-      # This is actually not a cop and inspects nothing. It just provides
-      # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
-      class Syntax < Cop
-        PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                       :end_pos)
-
-        ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
-
-        def self.offenses_from_processed_source(processed_source,
-                                                config, options)
-          cop = new(config, options)
-
-          if processed_source.parser_error
-            cop.add_offense_from_error(processed_source.parser_error)
-          end
-
+      # This cop repacks Parser's diagnostics/errors
+      # into RuboCop's offenses.
+      class Syntax < Base
+        def on_other_file
+          add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
           processed_source.diagnostics.each do |diagnostic|
-            cop.add_offense_from_diagnostic(diagnostic,
-                                            processed_source.ruby_version)
+            add_offense_from_diagnostic(diagnostic,
+                                        processed_source.ruby_version)
           end
-
-          cop.offenses
+          super
         end
 
+        private
+
         def add_offense_from_diagnostic(diagnostic, ruby_version)
           message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
             'configure using `TargetRubyVersion` parameter, under `AllCops`)'
-          add_offense(nil,
-                      location: diagnostic.location,
+          add_offense(diagnostic.location,
                       message: message,
                       severity: diagnostic.level)
         end
 
         def add_offense_from_error(error)
           message = beautify_message(error.message)
-          add_offense(nil,
-                      location: ERROR_SOURCE_RANGE,
-                      message: message,
-                      severity: :fatal)
+          add_global_offense(message, severity: :fatal)
         end
 
-        private
-
         def beautify_message(message)
           message = message.capitalize
           message << '.' unless message.end_with?('.')

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure `#to_json` includes an optional argument.
+      # When overriding `#to_json`, callers may invoke JSON
+      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # for an optional argument, your method should too.
+      #
+      # @example
+      #   # bad
+      #   def to_json
+      #   end
+      #
+      #   # good
+      #   def to_json(*_args)
+      #   end
+      #
+      class ToJSON < Cop
+        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+          'via JSON.generate(obj).'
+
+        def on_def(node)
+          return unless node.method?(:to_json) && node.arguments.empty?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            # The following used `*_args` because `to_json(*args)` has
+            # an offense of `Lint/UnusedMethodArgument` cop if `*args`
+            # is not used.
+            corrector.insert_after(node.loc.name, '(*_args)')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,11 @@ module RuboCop
       # This cop checks for underscore-prefixed variables that are actually
       # used.
       #
-      # @example
+      # 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
       #
@@ -14,7 +18,9 @@ module RuboCop
       #     do_something(_num)
       #   end
       #
-      # @example
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
       #
       #   # good
       #
@@ -22,15 +28,20 @@ module RuboCop
       #     do_something(num)
       #   end
       #
-      # @example
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
+      #
+      # @example AllowKeywordBlockArguments: true
       #
       #   # good
       #
-      #   [1, 2, 3].each do |_num|
-      #     do_something # not using `_num`
+      #   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.'.freeze
+        MSG = 'Do not use prefix `_` for a variable that is used.'
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -45,6 +56,7 @@ module RuboCop
         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
 
@@ -56,6 +68,14 @@ module RuboCop
 
           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

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

@@ -18,9 +18,9 @@ module RuboCop
       #
       #   1.is_a?(Integer)
       class UnifiedInteger < Cop
-        MSG = 'Use `Integer` instead of `%s`.'.freeze
+        MSG = 'Use `Integer` instead of `%<klass>s`.'
 
-        def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
+        def_node_matcher :fixnum_or_bignum_const, <<~PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
         PATTERN
 
@@ -29,7 +29,7 @@ module RuboCop
 
           return unless klass
 
-          add_offense(node, message: format(MSG, klass))
+          add_offense(node, message: format(MSG, klass: klass))
         end
 
         def autocorrect(node)