rubocop 0.93.1 → 1.79.2

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant quantifiers inside `Regexp` literals.
+      #
+      # It is always allowed when interpolation is used in a regexp literal,
+      # because it's unknown what kind of string will be expanded as a result:
+      #
+      # [source,ruby]
+      # ----
+      # /(?:a*#{interpolation})?/x
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /(?:x+)+/
+      #
+      #   # good
+      #   /(?:x)+/
+      #
+      #   # good
+      #   /(?:x+)/
+      #
+      #   # bad
+      #   /(?:x+)?/
+      #
+      #   # good
+      #   /(?:x)*/
+      #
+      #   # good
+      #   /(?:x*)/
+      class RedundantRegexpQuantifiers < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_REDUNDANT_QUANTIFIER = 'Replace redundant quantifiers ' \
+                                   '`%<inner_quantifier>s` and `%<outer_quantifier>s` ' \
+                                   'with a single `%<replacement>s`.'
+
+        def on_regexp(node)
+          return if node.interpolation?
+
+          each_redundantly_quantified_pair(node) do |group, child|
+            replacement = merged_quantifier(group, child)
+            add_offense(
+              quantifier_range(group, child),
+              message: message(group, child, replacement)
+            ) do |corrector|
+              # drop outer quantifier
+              corrector.replace(group.loc.quantifier, '')
+              # replace inner quantifier
+              corrector.replace(child.loc.quantifier, replacement)
+            end
+          end
+        end
+
+        private
+
+        def each_redundantly_quantified_pair(node)
+          seen = Set.new
+          node.parsed_tree&.each_expression do |(expr)|
+            next if seen.include?(expr) || !redundant_group?(expr) || !mergeable_quantifier(expr)
+
+            expr.each_expression do |(subexp)|
+              seen << subexp
+              break unless redundantly_quantifiable?(subexp)
+
+              yield(expr, subexp) if mergeable_quantifier(subexp)
+            end
+          end
+        end
+
+        def redundant_group?(expr)
+          expr.is?(:passive, :group) && expr.one? { |child| child.type != :free_space }
+        end
+
+        def redundantly_quantifiable?(node)
+          redundant_group?(node) || character_set?(node) || node.terminal?
+        end
+
+        def character_set?(expr)
+          expr.is?(:character, :set)
+        end
+
+        def mergeable_quantifier(expr)
+          # Merging reluctant or possessive quantifiers would be more complex,
+          # and Ruby does not emit warnings for these cases.
+          return unless expr.quantifier&.greedy?
+
+          # normalize quantifiers, e.g. "{1,}" => "+"
+          case expr.quantity
+          when [0, -1]
+            '*'
+          when [0, 1]
+            '?'
+          when [1, -1]
+            '+'
+          end
+        end
+
+        def merged_quantifier(exp1, exp2)
+          quantifier1 = mergeable_quantifier(exp1)
+          quantifier2 = mergeable_quantifier(exp2)
+          if quantifier1 == quantifier2
+            # (?:a+)+ equals (?:a+) ; (?:a*)* equals (?:a*) ; # (?:a?)? equals (?:a?)
+            quantifier1
+          else
+            # (?:a+)*, (?:a+)?, (?:a*)+, (?:a*)?, (?:a?)+, (?:a?)* - all equal (?:a*)
+            '*'
+          end
+        end
+
+        def quantifier_range(group, child)
+          range_between(child.loc.quantifier.begin_pos, group.loc.quantifier.end_pos)
+        end
+
+        def message(group, child, replacement)
+          format(
+            MSG_REDUNDANT_QUANTIFIER,
+            inner_quantifier: child.quantifier.to_s,
+            outer_quantifier: group.quantifier.to_s,
+            replacement: replacement
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -6,13 +6,22 @@ module RuboCop
       # Checks for unnecessary `require` statement.
       #
       # The following features are unnecessary `require` statement because
-      # they are already loaded.
+      # they are already loaded. e.g. Ruby 2.2:
       #
       #   ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }'
       #   ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13]
       #   ["enumerator.so", "rational.so", "complex.so", "thread.rb"]
       #
-      # This cop targets Ruby 2.2 or higher containing these 4 features.
+      # Below are the features that each `TargetRubyVersion` targets.
+      #
+      #   * 2.0+ ... `enumerator`
+      #   * 2.1+ ... `thread`
+      #   * 2.2+ ... Add `rational` and `complex` above
+      #   * 2.7+ ... Add `ruby2_keywords` above
+      #   * 3.1+ ... Add `fiber` above
+      #   * 3.2+ ... `set`
+      #
+      # This cop target those features.
       #
       # @example
       #   # bad
@@ -27,21 +36,42 @@ module RuboCop
 
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
+        RUBY_22_LOADED_FEATURES = %w[rational complex].freeze
 
-        def_node_matcher :unnecessary_require_statement?, <<~PATTERN
+        # @!method redundant_require_statement?(node)
+        def_node_matcher :redundant_require_statement?, <<~PATTERN
           (send nil? :require
-            (str {"enumerator" "rational" "complex" "thread"}))
+            (str #redundant_feature?))
         PATTERN
 
         def on_send(node)
-          return unless unnecessary_require_statement?(node)
+          return unless redundant_require_statement?(node)
 
           add_offense(node) do |corrector|
-            range = range_with_surrounding_space(range: node.loc.expression, side: :right)
+            if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+              corrector.insert_after(node.parent, "\nend")
+
+              range = range_with_surrounding_space(node.source_range, side: :right)
+            else
+              range = range_by_whole_lines(node.source_range, include_final_newline: true)
+            end
 
             corrector.remove(range)
           end
         end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def redundant_feature?(feature_name)
+          feature_name == 'enumerator' ||
+            (target_ruby_version >= 2.1 && feature_name == 'thread') ||
+            (target_ruby_version >= 2.2 && RUBY_22_LOADED_FEATURES.include?(feature_name)) ||
+            (target_ruby_version >= 2.7 && feature_name == 'ruby2_keywords') ||
+            (target_ruby_version >= 3.1 && feature_name == 'fiber') ||
+            (target_ruby_version >= 3.2 && feature_name == 'set')
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -3,19 +3,59 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant safe navigation calls.
-      # `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods
-      # are checked by default. These are customizable with `AllowedMethods` option.
+      # Checks for redundant safe navigation calls.
+      # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
+      # and an offense is not detected when the receiver is a constant. The detection also applies
+      # to `self`, and to literal receivers, except for `nil`.
       #
-      # This cop is marked as unsafe, because auto-correction can change the
-      # return type of the expression. An offending expression that previously
-      # could return `nil` will be auto-corrected to never return `nil`.
+      # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
+      # and `equal?` methods are checked by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
       #
       # In the example below, the safe navigation operator (`&.`) is unnecessary
       # because `NilClass` has methods like `respond_to?` and `is_a?`.
       #
+      # The `InferNonNilReceiver` option specifies whether to look into previous code
+      # paths to infer if the receiver can't be nil. This check is unsafe because the receiver
+      # can be redefined between the safe navigation call and previous regular method call.
+      # It does the inference only in the current scope, e.g. within the same method definition etc.
+      #
+      # The `AdditionalNilMethods` option specifies additional custom methods which are
+      # defined on `NilClass`. When `InferNonNilReceiver` is set, they are used to determine
+      # whether the receiver can be nil.
+      #
+      # @safety
+      #   This cop is unsafe, because autocorrection can change the return type of
+      #   the expression. An offending expression that previously could return `nil`
+      #   will be autocorrected to never return `nil`.
+      #
       # @example
       #   # bad
+      #   CamelCaseConst&.do_something
+      #
+      #   # good
+      #   CamelCaseConst.do_something
+      #
+      #   # bad
+      #   foo.to_s&.strip
+      #   foo.to_i&.zero?
+      #   foo.to_f&.zero?
+      #   foo.to_a&.size
+      #   foo.to_h&.size
+      #
+      #   # good
+      #   foo.to_s.strip
+      #   foo.to_i.zero?
+      #   foo.to_f.zero?
+      #   foo.to_a.size
+      #   foo.to_h.size
+      #
+      #   # bad
       #   do_something if attrs&.respond_to?(:[])
       #
       #   # good
@@ -34,44 +74,185 @@ module RuboCop
       #   # good - without `&.` this will always return `true`
       #   foo&.respond_to?(:to_a)
       #
+      #   # bad - for `nil`s conversion methods return default values for the type
+      #   foo&.to_h || {}
+      #   foo&.to_h { |k, v| [k, v] } || {}
+      #   foo&.to_a || []
+      #   foo&.to_i || 0
+      #   foo&.to_f || 0.0
+      #   foo&.to_s || ''
+      #
+      #   # good
+      #   foo.to_h
+      #   foo.to_h { |k, v| [k, v] }
+      #   foo.to_a
+      #   foo.to_i
+      #   foo.to_f
+      #   foo.to_s
+      #
+      #   # bad
+      #   self&.foo
+      #
+      #   # good
+      #   self.foo
+      #
+      # @example AllowedMethods: [nil_safe_method]
+      #   # bad
+      #   do_something if attrs&.nil_safe_method(:[])
+      #
+      #   # good
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
+      #
+      # @example InferNonNilReceiver: false (default)
+      #   # good
+      #   foo.bar
+      #   foo&.baz
+      #
+      # @example InferNonNilReceiver: true
+      #   # bad
+      #   foo.bar
+      #   foo&.baz # would raise on previous line if `foo` is nil
+      #
+      #   # good
+      #   foo.bar
+      #   foo.baz
+      #
+      #   # bad
+      #   if foo.condition?
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   if foo.condition?
+      #     foo.bar
+      #   end
+      #
+      #   # good (different scopes)
+      #   def method1
+      #     foo.bar
+      #   end
+      #
+      #   def method2
+      #     foo&.bar
+      #   end
+      #
+      # @example AdditionalNilMethods: [present?]
+      #   # good
+      #   foo.present?
+      #   foo&.bar
+      #
       class RedundantSafeNavigation < Base
         include AllowedMethods
-        include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Redundant safe navigation detected.'
+        MSG = 'Redundant safe navigation detected, use `.` instead.'
+        MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+        MSG_NON_NIL = 'Redundant safe navigation on non-nil receiver (detected by analyzing ' \
+                      'previous code/method invocations).'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
+        SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
+
+        GUARANTEED_INSTANCE_METHODS = %i[to_s to_i to_f to_a to_h].freeze
+
+        # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN
 
+        # @!method conversion_with_default?(node)
+        def_node_matcher :conversion_with_default?, <<~PATTERN
+          {
+            (or $(csend _ :to_h) (hash))
+            (or (block $(csend _ :to_h) ...) (hash))
+            (or $(csend _ :to_a) (array))
+            (or $(csend _ :to_i) (int 0))
+            (or $(csend _ :to_f) (float 0.0))
+            (or $(csend _ :to_s) (str empty?))
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
         def on_csend(node)
-          return unless check?(node) && allowed_method?(node.method_name)
-          return if respond_to_nil_specific_method?(node)
+          range = node.loc.dot
+
+          if infer_non_nil_receiver?
+            checker = Lint::Utils::NilReceiverChecker.new(node.receiver, additional_nil_methods)
+
+            if checker.cant_be_nil?
+              add_offense(range, message: MSG_NON_NIL) { |corrector| corrector.replace(range, '.') }
+              return
+            end
+          end
+
+          unless assume_receiver_instance_exists?(node.receiver)
+            return if !guaranteed_instance?(node.receiver) && !check?(node)
+            return if respond_to_nil_specific_method?(node)
+          end
+
+          add_offense(range) { |corrector| corrector.replace(range, '.') }
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # rubocop:disable Metrics/AbcSize
+        def on_or(node)
+          conversion_with_default?(node) do |send_node|
+            range = send_node.loc.dot.begin.join(node.source_range.end)
 
-          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
-          add_offense(range) do |corrector|
-            corrector.replace(node.loc.dot, '.')
+            add_offense(range, message: MSG_LITERAL) do |corrector|
+              corrector.replace(send_node.loc.dot, '.')
+
+              range_with_default = node.lhs.source_range.end.begin.join(node.source_range.end)
+              corrector.remove(range_with_default)
+            end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def assume_receiver_instance_exists?(receiver)
+          return true if receiver.const_type? && !receiver.short_name.match?(SNAKE_CASE)
+
+          receiver.self_type? || (receiver.literal? && !receiver.nil_type?)
+        end
+
+        def guaranteed_instance?(node)
+          receiver = if node.any_block_type?
+                       node.send_node
+                     else
+                       node
+                     end
+          return false unless receiver.send_type?
+
+          GUARANTEED_INSTANCE_METHODS.include?(receiver.method_name)
+        end
+
         def check?(node)
+          return false unless allowed_method?(node.method_name)
+
           parent = node.parent
           return false unless parent
 
           condition?(parent, node) ||
-            parent.and_type? ||
-            parent.or_type? ||
+            parent.operator_keyword? ||
             (parent.send_type? && parent.negation_method?)
         end
 
         def condition?(parent, node)
           (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
         end
+
+        def infer_non_nil_receiver?
+          cop_config['InferNonNilReceiver']
+        end
+
+        def additional_nil_methods
+          @additional_nil_methods ||=
+            Array(cop_config.fetch('AdditionalNilMethods', []).map(&:to_sym))
+        end
       end
     end
   end

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

@@ -3,52 +3,71 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for unneeded usages of splat expansion
+      # Checks for unneeded usages of splat expansion.
       #
       # @example
       #
       #   # bad
-      #
       #   a = *[1, 2, 3]
       #   a = *'a'
       #   a = *1
-      #
-      #   begin
-      #     foo
-      #   rescue *[StandardError, ApplicationError]
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3]
-      #     bar
-      #   else
-      #     baz
-      #   end
-      #
-      # @example
+      #   ['a', 'b', *%w(c d e), 'f', 'g']
       #
       #   # good
-      #
       #   c = [1, 2, 3]
       #   a = *c
       #   a, b = *c
       #   a, *b = *c
       #   a = *1..10
       #   a = ['a']
+      #   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
+      #
+      #   # bad
+      #   do_something(*['foo', 'bar', 'baz'])
+      #
+      #   # good
+      #   do_something('foo', 'bar', 'baz')
       #
+      #   # bad
+      #   begin
+      #     foo
+      #   rescue *[StandardError, ApplicationError]
+      #     bar
+      #   end
+      #
+      #   # good
       #   begin
       #     foo
       #   rescue StandardError, ApplicationError
       #     bar
       #   end
       #
+      #   # bad
+      #   case foo
+      #   when *[1, 2, 3]
+      #     bar
+      #   else
+      #     baz
+      #   end
+      #
+      #   # good
       #   case foo
       #   when 1, 2, 3
       #     bar
       #   else
       #     baz
       #   end
+      #
+      # @example AllowPercentLiteralArrayArgument: true (default)
+      #
+      #   # good
+      #   do_something(*%w[foo bar baz])
+      #
+      # @example AllowPercentLiteralArrayArgument: false
+      #
+      #   # bad
+      #   do_something(*%w[foo bar baz])
+      #
       class RedundantSplatExpansion < Base
         extend AutoCorrector
 
@@ -60,6 +79,7 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
+        # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
           {
             $(send (const {nil? cbase} :Array) :new ...)
@@ -67,21 +87,22 @@ module RuboCop
           }
         PATTERN
 
+        # @!method literal_expansion(node)
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
 
         def on_splat(node)
           redundant_splat_expansion(node) do
-            if array_splat?(node) &&
-               (method_argument?(node) || part_of_an_array?(node))
+            if array_splat?(node) && (method_argument?(node) || part_of_an_array?(node))
+              return if allow_percent_literal_array_argument? &&
+                        use_percent_literal_array_argument?(node)
+
               add_offense(node, message: ARRAY_PARAM_MSG) do |corrector|
                 autocorrect(corrector, node)
               end
             else
-              add_offense(node) do |corrector|
-                autocorrect(corrector, node)
-              end
+              add_offense(node) { |corrector| autocorrect(corrector, node) }
             end
           end
         end
@@ -100,8 +121,7 @@ module RuboCop
               return if array_new_inside_array_literal?(expanded_item)
 
               grandparent = node.parent.parent
-              return if grandparent &&
-                        !ASSIGNMENT_TYPES.include?(grandparent.type)
+              return if grandparent && !ASSIGNMENT_TYPES.include?(grandparent.type)
             end
 
             yield
@@ -115,27 +135,30 @@ module RuboCop
           grandparent.array_type? && grandparent.children.size > 1
         end
 
+        # rubocop:disable Metrics/AbcSize
         def replacement_range_and_content(node)
-          variable, = *node
-          loc = node.loc
+          variable = node.children.first
+          expression = node.source_range
 
           if array_new?(variable)
-            [node.parent.loc.expression, variable.source]
+            expression = node.parent.source_range if node.parent.array_type?
+            [expression, variable.source]
           elsif !variable.array_type?
-            [loc.expression, "[#{variable.source}]"]
+            [expression, "[#{variable.source}]"]
           elsif redundant_brackets?(node)
-            [loc.expression, remove_brackets(variable)]
+            [expression, remove_brackets(variable)]
           else
-            [loc.operator, '']
+            [node.loc.operator, '']
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def array_splat?(node)
           node.children.first.array_type?
         end
 
         def method_argument?(node)
-          node.parent.send_type?
+          node.parent.call_type?
         end
 
         def part_of_an_array?(node)
@@ -149,7 +172,7 @@ module RuboCop
           parent = node.parent
           grandparent = node.parent.parent
 
-          parent.when_type? || parent.send_type? || part_of_an_array?(node) ||
+          parent.when_type? || method_argument?(node) || part_of_an_array?(node) ||
             grandparent&.resbody_type?
         end
 
@@ -170,6 +193,17 @@ module RuboCop
             elements.join(', ')
           end
         end
+
+        def use_percent_literal_array_argument?(node)
+          argument = node.children.first
+
+          method_argument?(node) &&
+            (argument.percent_literal?(:string) || argument.percent_literal?(:symbol))
+        end
+
+        def allow_percent_literal_array_argument?
+          cop_config.fetch('AllowPercentLiteralArrayArgument', true)
+        end
       end
     end
   end