rubocop 0.76.0 → 1.50.0

data/lib/rubocop/cop/lint/{handle_exceptions.rb → suppressed_exception.rb}

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for *rescue* blocks with no body.
+      # Checks for `rescue` blocks with no body.
       #
-      # @example AllowComments: false (default)
+      # @example
       #
       #   # bad
       #   def some_method
@@ -14,80 +14,117 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   def some_method
+      #   begin
       #     do_something
       #   rescue
-      #     # do nothing
       #   end
       #
-      #   # bad
-      #   begin
+      #   # good
+      #   def some_method
       #     do_something
       #   rescue
+      #     handle_exception
       #   end
       #
-      #   # bad
+      #   # good
       #   begin
       #     do_something
       #   rescue
-      #     # do nothing
+      #     handle_exception
       #   end
       #
+      # @example AllowComments: true (default)
+      #
       #   # good
       #   def some_method
       #     do_something
       #   rescue
-      #     handle_exception
+      #     # do nothing
       #   end
       #
       #   # good
       #   begin
       #     do_something
       #   rescue
-      #     handle_exception
+      #     # do nothing
       #   end
       #
-      # @example AllowComments: true
+      # @example AllowComments: false
       #
       #   # bad
       #   def some_method
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
       #   # bad
       #   begin
       #     do_something
       #   rescue
+      #     # do nothing
       #   end
       #
+      # @example AllowNil: true (default)
+      #
       #   # good
       #   def some_method
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     nil
       #   end
       #
       #   # good
       #   begin
       #     do_something
       #   rescue
-      #     # do nothing but comment
+      #     # do nothing
       #   end
-      class HandleExceptions < Cop
+      #
+      #   # good
+      #   do_something rescue nil
+      #
+      # @example AllowNil: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   do_something rescue nil
+      class SuppressedException < Base
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
-          return if node.body
-          return if cop_config['AllowComments'] && comment_lines?(node)
+          return if node.body && !nil_body?(node)
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+          return if cop_config['AllowNil'] && nil_body?(node)
 
           add_offense(node)
         end
 
         private
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        def comment_between_rescue_and_end?(node)
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
+          return unless ancestor
+
+          end_line = ancestor.loc.end.line
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
+        end
+
+        def nil_body?(node)
+          node.body&.nil_type?
         end
       end
     end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for uses of literal strings converted to
+      # a symbol where a literal symbol could be used instead.
+      #
+      # There are two possible styles for this cop.
+      # `strict` (default) will register an offense for any incorrect usage.
+      # `consistent` additionally requires hashes to use the same style for
+      # every symbol key (ie. if any symbol key needs to be quoted it requires
+      # all keys to be quoted).
+      #
+      # @example
+      #   # bad
+      #   'string'.to_sym
+      #   :symbol.to_sym
+      #   'underscored_string'.to_sym
+      #   :'underscored_symbol'
+      #   'hyphenated-string'.to_sym
+      #
+      #   # good
+      #   :string
+      #   :symbol
+      #   :underscored_string
+      #   :underscored_symbol
+      #   :'hyphenated-string'
+      #
+      # @example EnforcedStyle: strict (default)
+      #
+      #   # bad
+      #   {
+      #     'a': 1,
+      #     "b": 2,
+      #     'c-d': 3
+      #   }
+      #
+      #   # good (don't quote keys that don't require quoting)
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     'c-d': 3
+      #   }
+      #
+      # @example EnforcedStyle: consistent
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (quote all keys if any need quoting)
+      #   {
+      #     'a': 1,
+      #     'b-c': 2
+      #   }
+      #
+      #   # good (no quoting required)
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
+      class SymbolConversion < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include SymbolHelp
+
+        MSG = 'Unnecessary symbol conversion; use `%<correction>s` instead.'
+        MSG_CONSISTENCY = 'Symbol hash key should be quoted for consistency; ' \
+                          'use `%<correction>s` instead.'
+        RESTRICT_ON_SEND = %i[to_sym intern].freeze
+
+        def on_send(node)
+          return unless node.receiver
+          return unless node.receiver.str_type? || node.receiver.sym_type?
+
+          register_offense(node, correction: node.receiver.value.to_sym.inspect)
+        end
+
+        def on_sym(node)
+          return if ignored_node?(node) || properly_quoted?(node.source, node.value.inspect)
+
+          # `alias` arguments are symbols but since a symbol that requires
+          # being quoted is not a valid method identifier, it can be ignored
+          return if in_alias?(node)
+
+          # The `%I[]` and `%i[]` macros are parsed as normal arrays of symbols
+          # so they need to be ignored.
+          return if in_percent_literal_array?(node)
+
+          # Symbol hash keys have a different format and need to be handled separately
+          return correct_hash_key(node) if hash_key?(node)
+
+          register_offense(node, correction: node.value.inspect)
+        end
+
+        def on_hash(node)
+          # For `EnforcedStyle: strict`, hash keys are evaluated in `on_sym`
+          return unless style == :consistent
+
+          keys = node.keys.select(&:sym_type?)
+
+          if keys.any? { |key| requires_quotes?(key) }
+            correct_inconsistent_hash_keys(keys)
+          else
+            # If there are no symbol keys requiring quoting,
+            # treat the hash like `EnforcedStyle: strict`.
+            keys.each { |key| correct_hash_key(key) }
+          end
+        end
+
+        private
+
+        def register_offense(node, correction:, message: format(MSG, correction: correction))
+          add_offense(node, message: message) { |corrector| corrector.replace(node, correction) }
+        end
+
+        def properly_quoted?(source, value)
+          return true if style == :strict && (!source.match?(/['"]/) || value.end_with?('='))
+
+          source == value ||
+            # `Symbol#inspect` uses double quotes, but allow single-quoted
+            # symbols to work as well.
+            source.tr("'", '"') == value
+        end
+
+        def requires_quotes?(sym_node)
+          sym_node.value.inspect.match?(/^:".*?"|=$/)
+        end
+
+        def in_alias?(node)
+          node.parent&.alias_type?
+        end
+
+        def in_percent_literal_array?(node)
+          node.parent&.array_type? && node.parent&.percent_literal?
+        end
+
+        def correct_hash_key(node)
+          # Although some operators can be converted to symbols normally
+          # (ie. `:==`), these are not accepted as hash keys and will
+          # raise a syntax error (eg. `{ ==: ... }`). Therefore, if the
+          # symbol does not start with an alphanumeric or underscore, it
+          # will be ignored.
+          return unless node.value.to_s.match?(/\A[a-z0-9_]/i)
+
+          correction = node.value.inspect
+          correction = correction.delete_prefix(':') if node.parent.colon?
+          return if properly_quoted?(node.source, correction)
+
+          register_offense(
+            node,
+            correction: correction,
+            message: format(MSG, correction: node.parent.colon? ? "#{correction}:" : correction)
+          )
+        end
+
+        def correct_inconsistent_hash_keys(keys)
+          keys.each do |key|
+            ignore_node(key)
+
+            next if requires_quotes?(key)
+            next if properly_quoted?(key.source, %("#{key.value}"))
+
+            correction = %("#{key.value}")
+            register_offense(
+              key,
+              correction: correction,
+              message: format(MSG_CONSISTENCY, correction: "#{correction}:")
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,56 +3,40 @@
 module RuboCop
   module Cop
     module Lint
-      # This is not actually a cop. It does not inspect anything. It just
-      # provides methods to repack Parser's diagnostics/errors
+      # Repacks 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
-
+      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,
-                      message: message,
-                      severity: diagnostic.level)
+          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?('.')
           message
         end
+
+        def find_severity(_range, _severity)
+          :fatal
+        end
       end
     end
   end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Ensures that `to_enum`/`enum_for`, called for the current method,
+      # has correct arguments.
+      #
+      # @example
+      #   # bad
+      #   def foo(x, y = 1)
+      #     return to_enum(__callee__, x) # `y` is missing
+      #   end
+      #
+      #   # good
+      #   def foo(x, y = 1)
+      #     # Alternatives to `__callee__` are `__method__` and `:foo`.
+      #     return to_enum(__callee__, x, y)
+      #   end
+      #
+      #   # good
+      #   def foo(x, y = 1)
+      #     # It is also allowed if it is wrapped in some method like Sorbet.
+      #     return to_enum(T.must(__callee__), x, y)
+      #   end
+      #
+      class ToEnumArguments < Base
+        MSG = 'Ensure you correctly provided all the arguments.'
+
+        RESTRICT_ON_SEND = %i[to_enum enum_for].freeze
+
+        # @!method enum_conversion_call?(node)
+        def_node_matcher :enum_conversion_call?, <<~PATTERN
+          (send {nil? self} {:to_enum :enum_for} $_ $...)
+        PATTERN
+
+        # @!method method_name?(node, name)
+        def_node_matcher :method_name?, <<~PATTERN
+          {(send nil? {:__method__ :__callee__}) (sym %1)}
+        PATTERN
+
+        # @!method passing_keyword_arg?(node, name)
+        def_node_matcher :passing_keyword_arg?, <<~PATTERN
+          (pair (sym %1) (lvar %1))
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return unless def_node
+
+          enum_conversion_call?(node) do |method_node, arguments|
+            next if method_node.call_type? &&
+                    !method_node.method?(:__method__) && !method_node.method?(:__callee__)
+            next if method_name?(method_node, def_node.method_name) &&
+                    arguments_match?(arguments, def_node)
+
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def arguments_match?(arguments, def_node)
+          index = 0
+
+          def_node.arguments.reject(&:blockarg_type?).all? do |def_arg|
+            send_arg = arguments[index]
+            case def_arg.type
+            when :arg, :restarg, :optarg
+              index += 1
+            end
+
+            send_arg && argument_match?(send_arg, def_arg)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def argument_match?(send_arg, def_arg)
+          def_arg_name = def_arg.children[0]
+
+          case def_arg.type
+          when :arg, :restarg
+            send_arg.source == def_arg.source
+          when :optarg
+            send_arg.source == def_arg_name.to_s
+          when :kwoptarg, :kwarg
+            send_arg.hash_type? &&
+              send_arg.pairs.any? { |pair| passing_keyword_arg?(pair, def_arg_name) }
+          when :kwrestarg
+            send_arg.each_child_node(:kwsplat).any? { |child| child.source == def_arg.source }
+          when :forward_arg
+            send_arg.forwarded_args_type?
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end

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

@@ -3,32 +3,40 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks to make sure `#to_json` includes an optional argument.
+      # 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
+      #   class Point
+      #     attr_reader :x, :y
+      #
+      #     # bad, incorrect arity
+      #     def to_json
+      #       JSON.generate([x, y])
+      #     end
+      #
+      #     # good, preserving args
+      #     def to_json(*args)
+      #       JSON.generate([x, y], *args)
+      #     end
       #
-      #   # good
-      #   def to_json(*_args)
+      #     # good, discarding args
+      #     def to_json(*_args)
+      #       JSON.generate([x, y])
+      #     end
       #   end
       #
-      class ToJSON < Cop
-        MSG = ' `#to_json` requires an optional argument to be parsable ' \
-          'via JSON.generate(obj).'
+      class ToJSON < Base
+        extend AutoCorrector
+
+        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|
+          add_offense(node) do |corrector|
             # The following used `*_args` because `to_json(*args)` has
             # an offense of `Lint/UnusedMethodArgument` cop if `*args`
             # is not used.

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for top level return with arguments. If there is a
+      # top-level return statement with an argument, then the argument is
+      # always ignored. This is detected automatically since Ruby 2.7.
+      #
+      # @example
+      #
+      #   # Detected since Ruby 2.7
+      #   return 1 # 1 is always ignored.
+      class TopLevelReturnWithArgument < Base
+        # This cop works by validating the ancestors of the return node. A
+        # top-level return node's ancestors should not be of block, def, or
+        # defs type.
+
+        MSG = 'Top level return with argument detected.'
+
+        def on_return(return_node)
+          add_offense(return_node) if return_node.arguments? && ancestors_valid?(return_node)
+        end
+
+        private
+
+        def ancestors_valid?(return_node)
+          prohibited_ancestors = return_node.each_ancestor(:block, :def, :defs)
+          prohibited_ancestors.none?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for trailing commas in attribute declarations, such as
+      # `#attr_reader`. Leaving a trailing comma will nullify the next method
+      # definition by overriding it with a getter method.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     attr_reader :foo,
+      #
+      #     def bar
+      #       puts "Unreachable."
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_reader :foo
+      #
+      #     def bar
+      #       puts "No problem!"
+      #     end
+      #   end
+      #
+      class TrailingCommaInAttributeDeclaration < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Avoid leaving a trailing comma in attribute declarations.'
+
+        def on_send(node)
+          return unless node.attribute_accessor? && node.arguments.last.def_type?
+
+          trailing_comma = trailing_comma_range(node)
+
+          add_offense(trailing_comma) { |corrector| corrector.remove(trailing_comma) }
+        end
+
+        private
+
+        def trailing_comma_range(node)
+          range_with_surrounding_space(
+            node.arguments[-2].source_range,
+            side: :right
+          ).end.resize(1)
+        end
+      end
+    end
+  end
+end