rubocop 1.48.0 → 1.50.2

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there are no repeated patterns used in `in` keywords.
+      #
+      # @example
+      #
+      #   # bad
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'first'
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'second'
+      #     do_something_else
+      #   end
+      #
+      #   # bad - repeated alternate patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | foo
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | baz
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated hash patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, foo: a
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, baz: c
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated array patterns with elements in the same order
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [foo, bar]
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [bar, foo]
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated the same patterns and guard conditions
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if bar
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if baz
+      #     second_method
+      #   end
+      #
+      class DuplicateMatchPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Duplicate `in` pattern detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          case_node.in_pattern_branches.each_with_object(Set.new) do |in_pattern_node, previous|
+            pattern = in_pattern_node.pattern
+            next if previous.add?(pattern_identity(pattern))
+
+            add_offense(pattern)
+          end
+        end
+
+        private
+
+        def pattern_identity(pattern)
+          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+                             pattern.children.map(&:source).sort.to_s
+                           else
+                             pattern.source
+                           end
+
+          return pattern_source unless (guard = pattern.parent.children[1])
+
+          pattern_source + guard.source
+        end
+      end
+    end
+  end
+end

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

@@ -25,7 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) { |corrector| corrector.remove(begin_node.source_range) }
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
       end
     end

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

@@ -131,12 +131,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
-          (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -281,7 +281,7 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
+            .all?(/\A\s*,\s*\z/)
         end
 
         SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for string conversion in string interpolation,
+      # Checks for string conversion in string interpolation, `print`, `puts`, and `warn` arguments,
       # which is redundant.
       #
       # @example
@@ -11,18 +11,26 @@ module RuboCop
       #   # bad
       #
       #   "result is #{something.to_s}"
+      #   print something.to_s
+      #   puts something.to_s
+      #   warn something.to_s
       #
       # @example
       #
       #   # good
       #
       #   "result is #{something}"
+      #   print something
+      #   puts something
+      #   warn something
+      #
       class RedundantStringCoercion < Base
         include Interpolation
         extend AutoCorrector
 
-        MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'
-        MSG_SELF = 'Use `self` instead of `Object#to_s` in interpolation.'
+        MSG_DEFAULT = 'Redundant use of `Object#to_s` in %<context>s.'
+        MSG_SELF = 'Use `self` instead of `Object#to_s` in %<context>s.'
+        RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
@@ -32,18 +40,30 @@ module RuboCop
 
           return unless to_s_without_args?(final_node)
 
-          message = final_node.receiver ? MSG_DEFAULT : MSG_SELF
-
-          add_offense(final_node.loc.selector, message: message) do |corrector|
-            receiver = final_node.receiver
-            corrector.replace(
-              final_node,
-              if receiver
-                receiver.source
-              else
-                'self'
-              end
-            )
+          register_offense(final_node, 'interpolation')
+        end
+
+        def on_send(node)
+          return if node.receiver
+
+          node.each_child_node(:send) do |child|
+            next unless child.method?(:to_s)
+
+            register_offense(child, "`#{node.method_name}`")
+          end
+        end
+
+        private
+
+        def register_offense(node, context)
+          receiver = node.receiver
+          template = receiver ? MSG_DEFAULT : MSG_SELF
+          message = format(template, context: context)
+
+          add_offense(node.loc.selector, message: message) do |corrector|
+            replacement = receiver ? receiver.source : 'self'
+
+            corrector.replace(node, replacement)
           end
         end
       end

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

@@ -33,6 +33,10 @@ module RuboCop
           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

@@ -14,8 +14,14 @@ module RuboCop
       #
       #   # good
       #   def foo(x, y = 1)
+      #     # Alternatives to `__callee__` are `__method__` and `:foo`.
       #     return to_enum(__callee__, x, y)
-      #     # alternatives to `__callee__` are `__method__` and `:foo`
+      #   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

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

@@ -111,9 +111,9 @@ module RuboCop
           return false unless node.block_type? || node.numblock_type?
 
           send_node = node.send_node
-          return false if matches_allowed_pattern?(send_node.source)
-
-          send_node.enumerable_method? || send_node.enumerator_method? || send_node.method?(:loop)
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
         end
 
         def check(node)

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

@@ -41,15 +41,23 @@ module RuboCop
         MSG = 'Useless method definition detected.'
 
         def on_def(node)
-          return if use_rest_or_optional_args?(node)
+          return if method_definition_with_modifier?(node) || use_rest_or_optional_args?(node)
           return unless delegating?(node.body, node)
 
-          add_offense(node) { |corrector| corrector.remove(node) }
+          add_offense(node) do |corrector|
+            range = node.parent&.send_type? ? node.parent : node
+
+            corrector.remove(range)
+          end
         end
         alias on_defs on_def
 
         private
 
+        def method_definition_with_modifier?(node)
+          node.parent&.send_type? && !node.parent&.non_bare_access_modifier?
+        end
+
         def use_rest_or_optional_args?(node)
           node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
         end

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

@@ -56,11 +56,13 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def only_reraising?(resbody_node)
           return false if use_exception_variable_in_ensure?(resbody_node)
 
           body = resbody_node.body
-          return false if body.nil? || !body.send_type? || !body.method?(:raise)
+
+          return false if body.nil? || !body.send_type? || !body.method?(:raise) || body.receiver
           return true unless body.arguments?
           return false if body.arguments.size > 1
 
@@ -68,6 +70,7 @@ module RuboCop
 
           exception_objects(resbody_node).include?(exception_name)
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def use_exception_variable_in_ensure?(resbody_node)
           return false unless (exception_variable = resbody_node.exception_variable)

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

@@ -59,10 +59,10 @@ module RuboCop
                                                    shuffle slice sort sort_by squeeze strip sub
                                                    succ swapcase tr tr_s transform_values
                                                    unicode_normalize uniq upcase].freeze
-        METHODS_REPLACABLE_BY_EACH = %i[collect map].freeze
+        METHODS_REPLACEABLE_BY_EACH = %i[collect map].freeze
 
         NONMUTATING_METHODS = (NONMUTATING_METHODS_WITH_BANG_VERSION +
-                               METHODS_REPLACABLE_BY_EACH).freeze
+                               METHODS_REPLACEABLE_BY_EACH).freeze
 
         def on_block(node)
           return unless node.body && !node.body.begin_type?
@@ -133,7 +133,11 @@ module RuboCop
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
 
-          suggestion = METHODS_REPLACABLE_BY_EACH.include?(method_name) ? 'each' : "#{method_name}!"
+          suggestion = if METHODS_REPLACEABLE_BY_EACH.include?(method_name)
+                         'each'
+                       else
+                         "#{method_name}!"
+                       end
           add_offense(node,
                       message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion))
         end

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -44,7 +44,7 @@ module RuboCop
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && node.block_type?
+          count_blocks? && (node.block_type? || node.numblock_type?)
         end
 
         def message(max)

data/lib/rubocop/cop/metrics/class_length.rb

@@ -42,6 +42,7 @@ module RuboCop
         def on_class(node)
           check_code_length(node)
         end
+        alias on_sclass on_class
 
         def on_casgn(node)
           parent = node.parent

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -10,7 +10,7 @@ module RuboCop
           include Util
 
           FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
-          CLASSLIKE_TYPES = %i[class module].freeze
+          CLASSLIKE_TYPES = %i[class module sclass].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -71,7 +71,7 @@ module RuboCop
         elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
-          parent.loc.end ? parent.loc.end.line : parent.loc.line
+          parent.loc.respond_to?(:end) && parent.loc.end ? parent.loc.end.line : parent.loc.line
         else
           node.loc.end.line
         end

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -100,6 +100,7 @@ module RuboCop
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
         return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
+        return if dispatch_node.assignment_method?
         return if dispatch_node.parenthesized?
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
         return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -175,7 +175,7 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.source_range, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -69,7 +69,7 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment = processed_source.find_comment { |c| same_line?(c, node) }
+        comment = processed_source.comments.find { |c| same_line?(c, node) }
         return unless comment
 
         comment_source = comment.source

data/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -57,7 +57,7 @@ module RuboCop
         CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
         def on_new_investigation
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next if !should_check?(token) || token.text.ascii_only?
 
             message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG

data/lib/rubocop/cop/naming/inclusive_language.rb

@@ -5,6 +5,7 @@ module RuboCop
     module Naming
       # Recommends the use of inclusive language instead of problematic terms.
       # The cop can check the following locations for offenses:
+      #
       # - identifiers
       # - constants
       # - variables
@@ -12,6 +13,7 @@ module RuboCop
       # - symbols
       # - comments
       # - file paths
+      #
       # Each of these locations can be individually enabled/disabled via configuration,
       # for example CheckIdentifiers = true/false.
       #
@@ -22,6 +24,9 @@ module RuboCop
       # `WholeWord: true` can be set on a flagged term to indicate the cop should only match when
       # a term matches the whole word (partial matches will not be offenses).
       #
+      # The cop supports autocorrection when there is only one suggestion. When there are multiple
+      # suggestions, the best suggestion cannot be identified and will not be autocorrected.
+      #
       # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
       #   # Suggest replacing identifier whitelist with allowlist
       #
@@ -68,6 +73,7 @@ module RuboCop
       #   TeslaVehicle
       class InclusiveLanguage < Base
         include RangeHelp
+        extend AutoCorrector
 
         EMPTY_ARRAY = [].freeze
         MSG = "Consider replacing '%<term>s'%<suffix>s."
@@ -92,7 +98,7 @@ module RuboCop
         private
 
         def investigate_tokens
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next unless check_token?(token.type)
 
             word_locations = scan_for_words(token.text)
@@ -104,9 +110,16 @@ module RuboCop
 
         def add_offenses_for_token(token, word_locations)
           word_locations.each do |word_location|
-            start_position = token.pos.begin_pos + token.pos.source.index(word_location.word)
-            range = range_between(start_position, start_position + word_location.word.length)
-            add_offense(range, message: create_message(word_location.word))
+            word = word_location.word
+            range = offense_range(token, word)
+
+            add_offense(range, message: create_message(word)) do |corrector|
+              suggestions = find_flagged_term(word)['Suggestions']
+
+              next unless suggestions.is_a?(String)
+
+              corrector.replace(range, suggestions)
+            end
           end
         end
 
@@ -264,6 +277,12 @@ module RuboCop
                            end
           " with #{suggestion_str}"
         end
+
+        def offense_range(token, word)
+          start_position = token.pos.begin_pos + token.pos.source.index(word)
+
+          range_between(start_position, start_position + word.length)
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/method_name.rb

@@ -10,8 +10,8 @@ module RuboCop
       #
       #   Naming/MethodName:
       #     AllowedPatterns:
-      #       - '\A\s*onSelectionBulkChange\s*'
-      #       - '\A\s*onSelectionCleared\s*'
+      #       - '\AonSelectionBulkChange\z'
+      #       - '\AonSelectionCleared\z'
       #
       # Method names matching patterns are always allowed.
       #

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -70,7 +70,7 @@ module RuboCop
 
         def check(send_node)
           return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
-          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+          return unless (grouped_style? && groupable_sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
@@ -127,12 +127,12 @@ module RuboCop
           style == :separated
         end
 
-        def sibling_accessors(send_node)
+        def groupable_sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
             sibling.attribute_accessor? &&
               sibling.method?(send_node.method_name) &&
               node_visibility(sibling) == node_visibility(send_node) &&
-              !previous_line_comment?(sibling)
+              groupable_accessor?(sibling) && !previous_line_comment?(sibling)
           end
         end
 
@@ -143,7 +143,7 @@ module RuboCop
 
         def preferred_accessors(node)
           if grouped_style?
-            accessors = sibling_accessors(node)
+            accessors = groupable_sibling_accessors(node)
             group_accessors(node, accessors) if node.loc == accessors.first.loc
           else
             separate_accessors(node)

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -11,7 +11,7 @@ module RuboCop
       #
       #   Moving from compact to nested children requires knowledge of whether the
       #   outer parent is a module or a class. Moving from nested to compact requires
-      #   verification that the outer parent is defined elsewhere. Rubocop does not
+      #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
       #