rubocop 1.45.1 → 1.50.1

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

@@ -100,8 +100,10 @@ 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 node.respond_to?(:parenthesized?) && !node.parenthesized?
-        return unless last_expression?(dispatch_node) || method_dispatch_as_argument?(dispatch_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)
 
         def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
@@ -132,9 +134,12 @@ module RuboCop
         ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
-      def last_expression?(ancestor)
-        ancestor.right_sibling ||
-          ancestor.each_ancestor.find { |node| node.assignment? || node.send_type? }&.right_sibling
+      def last_expression?(node)
+        return false if node.right_sibling
+        return true unless (assignment_node = node.each_ancestor.find(&:assignment?))
+        return last_expression?(assignment_node.parent) if assignment_node.parent&.assignment?
+
+        !assignment_node.right_sibling
       end
 
       def method_dispatch_as_argument?(method_dispatch_node)

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

@@ -159,7 +159,7 @@ module RuboCop
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         end
@@ -175,11 +175,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.loc.expression.source
+          body_source = transforming_body_expr.source
           if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
             body_source = "{ #{body_source} }"
           end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum branches count.
+    module MinBranchesCount
+      private
+
+      def min_branches_count?(node)
+        branches =
+          if node.case_type?
+            node.when_branches
+          elsif node.if_type?
+            if_conditional_branches(node)
+          else
+            raise ArgumentError, "Unsupported #{node.type.inspect} node type"
+          end
+
+        branches.size >= min_branches_count
+      end
+
+      def min_branches_count
+        length = cop_config['MinBranchesCount'] || 3
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBranchesCount needs to be a positive integer!'
+      end
+
+      def if_conditional_branches(node, branches = [])
+        return [] if node.nil? || !node.if_type?
+
+        branches << node.if_branch
+
+        else_branch = node.else_branch
+        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        branches
+      end
+    end
+  end
+end

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# TEAM: backend_infra
-# WATCHERS: maxh
-
 module RuboCop
   module Cop
     # Common functionality for checking for a line break before each

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

@@ -10,7 +10,7 @@ module RuboCop
       def get_source_range(node, comments_as_separators)
         unless comments_as_separators
           first_comment = processed_source.ast_with_comments[node].first
-          return first_comment.loc.expression unless first_comment.nil?
+          return first_comment.source_range unless first_comment.nil?
         end
         node.source_range
       end

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

@@ -132,12 +132,7 @@ module RuboCop
       end
 
       def range_with_comments(node)
-        ranges = [
-          node,
-          *@processed_source.ast_with_comments[node]
-        ].map do |element|
-          element.location.expression
-        end
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
         ranges.reduce do |result, range|
           add_range(result, range)
         end

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

@@ -65,14 +65,14 @@ module RuboCop
       end
 
       def method_source(if_body)
-        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+        range_between(if_body.source_range.begin_pos, if_body.loc.selector.end_pos).source
       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.loc.expression.source
+        comment_source = comment.source
         comment_source unless comment_disables_cop?(comment_source)
       end
 

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

@@ -75,7 +75,7 @@ module RuboCop
 
       def inside_comment?(range, comma_offset)
         comment = processed_source.comment_at_line(range.line)
-        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.

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/heredoc_delimiter_case.rb

@@ -38,7 +38,7 @@ module RuboCop
           return if correct_case_delimiters?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
-            expr = node.loc.expression
+            expr = node.source_range
 
             corrector.replace(expr, correct_delimiters(expr.source))
             corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))

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.
       #
@@ -67,7 +67,7 @@ module RuboCop
 
         def range_position(node)
           selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.loc.expression.end_pos
+          expr_end_pos = node.source_range.end_pos
 
           range_between(selector_end_pos, expr_end_pos)
         end

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

@@ -72,7 +72,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.loc.expression,
+                node.first_argument.source_range,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end

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

@@ -92,7 +92,7 @@ module RuboCop
 
         def offense_range(resbody)
           variable = resbody.exception_variable
-          variable.loc.expression
+          variable.source_range
         end
 
         def variable_name_matches?(node, name)

data/lib/rubocop/cop/registry.rb

@@ -197,7 +197,9 @@ module RuboCop
       def enabled?(cop, config)
         return true if options[:only]&.include?(cop.cop_name)
 
-        cfg = config.for_cop(cop)
+        # We need to use `cop_name` in this case, because `for_cop` uses caching
+        # which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop.cop_name)
 
         cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
 

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

@@ -7,19 +7,32 @@ module RuboCop
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
-      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
-      # or disabling this cop.
+      # NOTE: If there is a method call before the accessor method it is always allowed
+      # as it might be intended like Sorbet.
       #
       # @example EnforcedStyle: grouped (default)
       #   # bad
       #   class Foo
       #     attr_reader :bar
+      #     attr_reader :bax
       #     attr_reader :baz
       #   end
       #
       #   # good
       #   class Foo
-      #     attr_reader :bar, :baz
+      #     attr_reader :bar, :bax, :baz
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # may be intended comment for bar.
+      #     attr_reader :bar
+      #
+      #     sig { returns(String) }
+      #     attr_reader :bax
+      #
+      #     may_be_intended_annotation :baz
+      #     attr_reader :baz
       #   end
       #
       # @example EnforcedStyle: separated
@@ -43,11 +56,9 @@ module RuboCop
         GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
         SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
 
-        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
-
         def on_class(node)
           class_send_elements(node).each do |macro|
-            next unless accessor?(macro)
+            next unless macro.attribute_accessor?
 
             check(macro)
           end
@@ -58,8 +69,8 @@ module RuboCop
         private
 
         def check(send_node)
-          return if previous_line_comment?(send_node)
-          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
+          return unless (grouped_style? && groupable_sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
@@ -72,7 +83,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(node.loc.expression, side: :left)
+            range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
           end
         end
@@ -81,6 +92,21 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        def groupable_accessor?(node)
+          return true unless (previous_expression = node.left_siblings.last)
+
+          # Accessors with Sorbet `sig { ... }` blocks shouldn't be groupable.
+          if previous_expression.block_type?
+            previous_expression.child_nodes.each do |child_node|
+              break previous_expression = child_node if child_node.send_type?
+            end
+          end
+
+          return true unless previous_expression.send_type?
+
+          previous_expression.attribute_accessor? || previous_expression.access_modifier?
+        end
+
         def class_send_elements(class_node)
           class_def = class_node.body
 
@@ -93,10 +119,6 @@ module RuboCop
           end
         end
 
-        def accessor?(send_node)
-          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
-        end
-
         def grouped_style?
           style == :grouped
         end
@@ -105,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|
-            accessor?(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
 
@@ -121,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/arguments_forwarding.rb

@@ -124,9 +124,9 @@ module RuboCop
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)
           add_offense(arguments_range(forwarding_method)) do |corrector|
-            range = range_between(
-              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
-            )
+            begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
+            range = range_between(begin_pos, forwarding_method.source_range.end_pos)
+
             corrector.replace(range, '(...)')
           end
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       # `(array1 & array2).any?` and is more readable.
       #
       # @safety
-      #   This cop cannot guarantee that array1 and array2 are
+      #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
       #
       # @example

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)

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

@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def parts(comment)
-          expr = comment.loc.expression
+          expr = comment.source_range
           eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = eq_end_part(comment, expr)
           contents = range_between(eq_begin.end_pos, eq_end.begin_pos)

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

@@ -299,7 +299,7 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          corrector.remove(range_with_surrounding_space(comment.loc.expression, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
           remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
@@ -314,7 +314,7 @@ module RuboCop
         end
 
         def remove_trailing_whitespace(corrector, range, comment)
-          range_of_trailing = range.end.join(comment.loc.expression.begin)
+          range_of_trailing = range.end.join(comment.source_range.begin)
 
           corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
         end
@@ -342,6 +342,7 @@ module RuboCop
         end
 
         def proper_block_style?(node)
+          return true if require_braces?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -352,6 +353,14 @@ module RuboCop
           end
         end
 
+        def require_braces?(node)
+          return false unless node.braces?
+
+          node.each_ancestor(:send).any? do |send|
+            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
+          end
+        end
+
         def special_method?(method_name)
           allowed_method?(method_name) ||
             matches_allowed_pattern?(method_name) ||

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

@@ -11,12 +11,14 @@ module RuboCop
       #   so if the original conditional used a different equality operator, the
       #   behavior may be different.
       #
-      # @example
+      # @example MinBranchesCount: 3 (default)
       #   # bad
       #   if status == :active
       #     perform_action
       #   elsif status == :inactive || status == :hibernating
       #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
@@ -27,12 +29,27 @@ module RuboCop
       #     perform_action
       #   when :inactive, :hibernating
       #     check_timeout
+      #   when :invalid
+      #     report_invalid
+      #   else
+      #     final_action
+      #   end
+      #
+      # @example MinBranchesCount: 4
+      #   # good
+      #   if status == :active
+      #     perform_action
+      #   elsif status == :inactive || status == :hibernating
+      #     check_timeout
+      #   elsif status == :invalid
+      #     report_invalid
       #   else
       #     final_action
       #   end
       #
       class CaseLikeIf < Base
         include RangeHelp
+        include MinBranchesCount
         extend AutoCorrector
 
         MSG = 'Convert `if-elsif` to `case-when`.'
@@ -78,7 +95,7 @@ module RuboCop
 
         def should_check?(node)
           !node.unless? && !node.elsif? && !node.modifier_form? && !node.ternary? &&
-            node.elsif_conditional?
+            node.elsif_conditional? && min_branches_count?(node)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -239,7 +256,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+          range_between(node.parent.loc.keyword.begin_pos, node.source_range.end_pos)
         end
 
         # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)

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.
       #