rubocop 1.71.0 → 1.71.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f4339f6b223b2a7fd5f68764dd3030e5cb83925c0605414459ed0f3d2543510
-  data.tar.gz: 525042279be387c345b3efd57ed7ca976e3eda5b15ba9723485b72f3a083816e
+  metadata.gz: 8d7c6408a777042eced58bec2bc889312b24d8701f5db99da3b471088f589d6f
+  data.tar.gz: 27423e682d55f04840a3bf3d5e0301556e4a1c419857e3422ced38ec423c0003
 SHA512:
-  metadata.gz: 404c792e4624474f907576ef9c73fc3ee09a5736c63becf75197fe40d5e9fdefb7c2cb6bc22326857d3b5065f50badd1a6a4d8f7cecd219fb6ec7280bb95a97a
-  data.tar.gz: 6e3071938d0f6d7850a732c41ce55890c6a2ba8bcd352df28203c136453cf249fd21a10c9c3d1ea7762376466a669a287efb56c8b7505877d8b17cacdd5dd059
+  metadata.gz: 8729a8ea3adae11fcb2501bfea338821a8f9894209ea6fb482b62ebfae87019e07ded7bf02d3371c18726b28c2491c79952e7b86c193388a045f886a833b427c
+  data.tar.gz: 44251afbbbc2aa7c121033ea05f25e1b3447afba7487d04a81f9463347ba28bcea05bdc2e434248f15cd235d9e452cb3f9f378f94adb5507eeb6d5ce58ba4119

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -102,7 +102,7 @@ module RuboCop
       end
 
       def string_continuation?(node)
-        (node.str_type? || node.dstr_type? || node.xstr_type?) && node.source.match?(/\\\s*$/)
+        node.type?(:str, :dstr, :xstr) && node.source.match?(/\\\s*$/)
       end
 
       def multiline_string?(node)

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -66,7 +66,7 @@ module RuboCop
 
         def conditional_declaration?(nodes)
           parent = nodes[0].each_ancestor.find { |ancestor| !ancestor.begin_type? }
-          return false unless parent&.if_type? || parent&.when_type?
+          return false unless parent&.type?(:if, :when)
 
           root_conditional_node = parent.if_type? ? parent : parent.parent
           nodes.all? { |node| within_conditional?(node, root_conditional_node) }

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -62,7 +62,7 @@ module RuboCop
         private
 
         def valid_method_name?(node)
-          node.first_argument.str_type? || node.first_argument.sym_type?
+          node.first_argument.type?(:str, :sym)
         end
 
         def method_directives(node)

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      class NodePatternGroups
+        # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
+        #
+        # Looks for sequences and subsequences where the first item is a `node_type` node,
+        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # node type).
+        #
+        # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`
+        # in order to find node types in a `union` node that can be rewritten as a node group.
+        #
+        # NOTE: The `on_*` methods in this class relate not to the normal node types but
+        # rather to the Node Pattern node types. Not every node type is handled.
+        #
+        class ASTProcessor
+          include ::AST::Processor::Mixin
+
+          def handler_missing(node)
+            node.updated(nil, process_children(node))
+          end
+
+          # Look for `sequence` and `subsequence` nodes that contain a `node_type` node as
+          # their first child. These are rewritten as `node_sequence` nodes so that it is
+          # possible to compare nodes while looking for replacement candidates for node groups.
+          # This is necessary so that extended patterns can be matched and replaced.
+          # ie. `{(send _ :foo ...) (csend _ :foo ...)}` can become `(call _ :foo ...)`
+          def on_sequence(node)
+            first_child = node.child
+
+            if first_child.type == :node_type
+              children = [first_child.child, *process_children(node, 1..)]
+
+              # The `node_sequence` node contains the `node_type` symbol as its first child,
+              # followed by all the other nodes contained in the `sequence` node.
+              # The location is copied from the sequence, so that the entire sequence can
+              # eventually be corrected in the cop.
+              n(:node_sequence, children, location: node.location)
+            else
+              node.updated(nil, process_children(node))
+            end
+          end
+          alias on_subsequence on_sequence
+
+          private
+
+          def n(type, children = [], properties = {})
+            NodePattern::Node.new(type, children, properties)
+          end
+
+          def process_children(node, range = 0..-1)
+            node.children[range].map do |child|
+              child.is_a?(::AST::Node) ? process(child) : child
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_walker.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # rubocop:disable InternalAffairs/RedundantSourceRange - node here is a `NodePattern::Node`
+      class NodePatternGroups
+        # Walks an AST that has been processed by `InternalAffairs::NodePatternGroups::Processor`
+        # in order to find `node_type` and `node_sequence` nodes that can be replaced with a node
+        # group in `InternalAffairs/NodePatternGroups`.
+        #
+        # Calling `ASTWalker#walk` sets `node_groups` with an array of `NodeGroup` structs
+        # that contain metadata about nodes that can be replaced, including location data. That
+        # metadata is used by the cop to register offenses and perform corrections.
+        class ASTWalker
+          # Struct to contain data about parts of a node pattern that can be replaced
+          NodeGroup = Struct.new(
+            :name,             # The name of the node group that will be inserted
+            :union,            # The entire `union` node
+            :node_types,       # An array of `node_type` nodes that will be removed
+            :sequence?,        # The pattern matches a node type with given attributes
+            :start_index,      # The index in the union of the first node type to remove
+            :offense_range,    # The range to mark an offense on
+            :ranges,           # Range of each element to remove, since they may not be adjacent
+            :pipe,             # Is the union delimited by pipes?
+            :other_elements?,  # Does the union have other elements other than those to remove?
+            keyword_init: true
+          )
+
+          def initialize
+            reset!
+          end
+
+          def reset!
+            @node_groups = []
+          end
+
+          attr_reader :node_groups
+
+          # Recursively walk the AST in a depth-first manner.
+          # Only `union` nodes are handled further.
+          def walk(node)
+            return if node.nil?
+
+            on_union(node) if node.type == :union
+
+            node.child_nodes.each do |child|
+              walk(child)
+            end
+          end
+
+          # Search `union` nodes for `node_type` and `node_sequence` nodes that can be
+          # collapsed into a node group.
+          # * `node_type` nodes are nodes with no further configuration (ie. `send`)
+          # * `node_sequence` nodes are nodes with further configuration (ie. `(send ...)`)
+          #
+          # Each group of types that can be collapsed will have a `NodeGroup` record added
+          # to `node_groups`, which is then used by the cop.
+          def on_union(node)
+            all_node_types = each_child_node(node, :node_type, :node_sequence).to_a
+
+            each_node_group(all_node_types) do |group_name, node_types|
+              next unless sequences_match?(node_types)
+
+              node_groups << node_group_data(
+                group_name, node, node_types,
+                all_node_types.index(node_types.first),
+                (node.children - node_types).any?
+              )
+            end
+          end
+
+          private
+
+          def each_child_node(node, *types)
+            return to_enum(__method__, node, *types) unless block_given?
+
+            node.children.each do |child|
+              yield child if types.empty? || types.include?(child.type)
+            end
+
+            self
+          end
+
+          def each_node_group(types_to_check)
+            # Find all node groups where all of the members are present in the union
+            type_names = types_to_check.map(&:child)
+
+            NODE_GROUPS.select { |_, group| group & type_names == group }.each_key do |name|
+              nodes = get_relevant_nodes(types_to_check, name)
+
+              yield name, nodes
+            end
+          end
+
+          def get_relevant_nodes(node_types, group_name)
+            node_types.each_with_object([]) do |node_type, arr|
+              next unless NODE_GROUPS[group_name].include?(node_type.child)
+
+              arr << node_type
+            end
+          end
+
+          def node_group_data(name, union, node_types, start_index, other)
+            NodeGroup.new(
+              name: name,
+              union: union,
+              node_types: node_types,
+              sequence?: node_types.first.type == :node_sequence,
+              start_index: start_index,
+              pipe: union.source_range.source['|'],
+              other_elements?: other
+            )
+          end
+
+          def sequences_match?(types)
+            # Ensure all given types have the same type and the same sequence
+            # ie. `(send ...)` and `(csend ...) is a match
+            #     `(send)` and `(csend ...)` is not a match
+            #     `send` and `(csend ...)` is not a match
+
+            types.each_cons(2).all? do |left, right|
+              left.type == right.type && left.children[1..] == right.children[1..]
+            end
+          end
+        end
+      end
+      # rubocop:enable InternalAffairs/RedundantSourceRange
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_pattern_groups.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use node groups (`any_block`, `argument`, `boolean`, `call`, `numeric`, `range`)
+      # in node patterns instead of a union (`{ ... }`) of the member types of the group.
+      #
+      # @example
+      #   # bad
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     {send csend}
+      #   PATTERN
+      #
+      #   # good
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     call
+      #   PATTERN
+      #
+      class NodePatternGroups < Base
+        require_relative 'node_pattern_groups/ast_processor'
+        require_relative 'node_pattern_groups/ast_walker'
+
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace `%<names>s` in node pattern union with `%<replacement>s`.'
+        RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].freeze
+        NODE_GROUPS = {
+          any_block: %i[block numblock],
+          argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
+          boolean: %i[true false],
+          call: %i[send csend],
+          numeric: %i[int float rational complex],
+          range: %i[irange erange]
+        }.freeze
+
+        def on_new_investigation
+          @walker = ASTWalker.new
+        end
+
+        # When a Node Pattern matcher is defined, investigate the pattern string to search
+        # for node types that can be replaced with a node group (ie. `{send csend}` can be
+        # replaced with `call`).
+        #
+        # In order to deal with node patterns in an efficient and non-brittle way, we will
+        # parse the Node Pattern string given to this `send` node using
+        # `RuboCop::AST::NodePattern::Parser::WithMeta`. `WithMeta` is important! We need
+        # location information so that we can calculate the exact locations within the
+        # pattern to report and correct.
+        #
+        # The resulting AST is processed by `NodePatternGroups::ASTProccessor` which rewrites
+        # the AST slightly to handle node sequences (ie. `(send _ :foo ...)`). See the
+        # documentation of that class for more details.
+        #
+        # Then the processed AST is walked, and metadata is collected for node types that
+        # can be replaced with a node group.
+        #
+        # Finally, the metadata is used to register offenses and make corrections, using
+        # the location data captured earlier. The ranges captured while parsing the Node
+        # Pattern are offset using the string argument to this `send` node to ensure
+        # that offenses are registered at the correct location.
+        #
+        def on_send(node)
+          pattern_node = node.arguments[1]
+          return unless acceptable_heredoc?(pattern_node) || pattern_node.str_type?
+
+          process_pattern(pattern_node)
+          return if node_groups.nil?
+
+          apply_range_offsets(pattern_node)
+
+          node_groups.each_with_index do |group, index|
+            register_offense(group, index)
+          end
+        end
+
+        def after_send(_)
+          @walker.reset!
+        end
+
+        private
+
+        def node_groups
+          @walker.node_groups
+        end
+
+        # rubocop:disable InternalAffairs/RedundantSourceRange -- `node` here is a NodePatternNode
+        def register_offense(group, index)
+          replacement = replacement(group)
+          message = format(
+            MSG,
+            names: group.node_types.map { |node| node.source_range.source }.join('`, `'),
+            replacement: replacement
+          )
+
+          add_offense(group.offense_range, message: message) do |corrector|
+            # Only correct one group at a time to avoid clobbering.
+            # Other offenses will be corrected in the subsequent iterations of the
+            # correction loop.
+            next if index.positive?
+
+            if group.other_elements?
+              replace_types_with_node_group(corrector, group, replacement)
+            else
+              replace_union(corrector, group, replacement)
+            end
+          end
+        end
+
+        def replacement(group)
+          if group.sequence?
+            # If the original nodes were in a sequence (ie. wrapped in parentheses),
+            # use it to generate the resulting NodePattern syntax.
+            first_node_type = group.node_types.first
+            template = first_node_type.source_range.source
+            template.sub(first_node_type.child.to_s, group.name.to_s)
+          else
+            group.name
+          end
+        end
+        # rubocop:enable InternalAffairs/RedundantSourceRange
+
+        # When there are other elements in the union, remove the node types that can be replaced.
+        def replace_types_with_node_group(corrector, group, replacement)
+          ranges = group.ranges.map.with_index do |range, index|
+            # Collect whitespace and pipes preceding each element
+            range_for_full_union_element(range, index, group.pipe)
+          end
+
+          ranges.each { |range| corrector.remove(range) }
+
+          corrector.insert_before(ranges.first, replacement)
+        end
+
+        # If the union contains pipes, remove the pipe character as well.
+        # Unfortunately we don't get the location of the pipe in `loc` object, so we have
+        # to find it.
+        def range_for_full_union_element(range, index, pipe)
+          if index.positive?
+            range = if pipe
+                      range_with_preceding_pipe(range)
+                    else
+                      range_with_surrounding_space(range: range, side: :left, newlines: true)
+                    end
+          end
+
+          range
+        end
+
+        # Collect a preceding pipe and any whitespace left of the pipe
+        def range_with_preceding_pipe(range)
+          pos = range.begin_pos - 1
+
+          while pos
+            unless processed_source.buffer.source[pos].match?(/[\s|]/)
+              return range.with(begin_pos: pos + 1)
+            end
+
+            pos -= 1
+          end
+
+          range
+        end
+
+        # When there are no other elements, the entire union can be replaced
+        def replace_union(corrector, group, replacement)
+          corrector.replace(group.ranges.first, replacement)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # Calculate the ranges for each node within the pattern string that will
+        # be replaced or removed. Takes the offset of the string node into account.
+        def apply_range_offsets(pattern_node)
+          range, offset = range_with_offset(pattern_node)
+
+          node_groups.each do |node_group|
+            node_group.ranges ||= []
+            node_group.offense_range = pattern_range(range, node_group.union, offset)
+
+            if node_group.other_elements?
+              node_group.node_types.each do |node_type|
+                node_group.ranges << pattern_range(range, node_type, offset)
+              end
+            else
+              node_group.ranges << node_group.offense_range
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def pattern_range(range, node, offset)
+          begin_pos = node.source_range.begin_pos
+          end_pos = node.source_range.end_pos
+          size = end_pos - begin_pos
+
+          range.adjust(begin_pos: begin_pos + offset).resize(size)
+        end
+
+        def range_with_offset(pattern_node)
+          if pattern_node.heredoc?
+            [pattern_node.loc.heredoc_body, 0]
+          else
+            [pattern_node.source_range, pattern_node.loc.begin.size]
+          end
+        end
+
+        # A heredoc can be a `dstr` without interpolation, but if there is interpolation
+        # there'll be a `begin` node, in which case, we cannot evaluate the pattern.
+        def acceptable_heredoc?(node)
+          node.type?(:str, :dstr) && node.heredoc? && node.each_child_node(:begin).none?
+        end
+
+        def process_pattern(pattern_node)
+          parser = RuboCop::AST::NodePattern::Parser::WithMeta.new
+          ast = parser.parse(pattern_value(pattern_node))
+          ast = ASTProcessor.new.process(ast)
+          @walker.walk(ast)
+        rescue RuboCop::AST::NodePattern::Invalid
+          # if the pattern is invalid, no offenses will be registered
+        end
+
+        def pattern_value(pattern_node)
+          pattern_node.heredoc? ? pattern_node.loc.heredoc_body.source : pattern_node.value
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_multiple_predicates.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `node.type?(:foo, :bar)` instead of `node.foo_type? || node.bar_type?`,
+      # and `!node.type?(:foo, :bar)` instead of `!node.foo_type? && !node.bar_type?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.str_type? || node.sym_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym)
+      #
+      #   # bad
+      #   node.type?(:str, :sym) || node.boolean_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym, :boolean)
+      #
+      #   # bad
+      #   !node.str_type? && !node.sym_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym)
+      #
+      #   # bad
+      #   !node.type?(:str, :sym) && !node.boolean_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym, :boolean)
+      #
+      class NodeTypeMultiplePredicates < Base
+        extend AutoCorrector
+
+        MSG_OR = 'Use `%<replacement>s` instead of checking for multiple node types.'
+        MSG_AND = 'Use `%<replacement>s` instead of checking against multiple node types.'
+
+        # @!method one_of_node_types?(node)
+        def_node_matcher :one_of_node_types?, <<~PATTERN
+          (or $(call _receiver #type_predicate?) (call _receiver #type_predicate?))
+        PATTERN
+
+        # @!method or_another_type?(node)
+        def_node_matcher :or_another_type?, <<~PATTERN
+          (or {
+            $(call _receiver :type? sym+) (call _receiver #type_predicate?) |
+            (call _receiver #type_predicate?) $(call _receiver :type? sym+)
+          })
+        PATTERN
+
+        # @!method none_of_node_types?(node)
+        def_node_matcher :none_of_node_types?, <<~PATTERN
+          (and
+            (send $(call _receiver #type_predicate?) :!)
+            (send (call _receiver #type_predicate?) :!)
+          )
+        PATTERN
+
+        # @!method and_not_another_type?(node)
+        def_node_matcher :and_not_another_type?, <<~PATTERN
+          (and {
+            (send $(call _receiver :type? sym+) :!) (send (call _receiver #type_predicate?) :!) |
+            (send (call _receiver #type_predicate?) :!) (send $(call _receiver :type? sym+) :!)
+          })
+        PATTERN
+
+        def on_or(node)
+          return unless (send_node = one_of_node_types?(node) || or_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = replacement(node, send_node)
+          add_offense(node, message: format(MSG_OR, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def on_and(node)
+          return unless (send_node = none_of_node_types?(node) || and_not_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = "!#{replacement(node, send_node)}"
+
+          add_offense(node, message: format(MSG_AND, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def type_predicate?(method_name)
+          method_name.end_with?('_type?')
+        end
+
+        def replacement(node, send_node)
+          send_node = send_node.children.first if send_node.method?(:!)
+
+          types = types(node)
+          receiver = send_node.receiver.source
+          dot = send_node.loc.dot.source
+
+          "#{receiver}#{dot}type?(:#{types.join(', :')})"
+        end
+
+        def types(node)
+          [types_in_branch(node.lhs), types_in_branch(node.rhs)]
+        end
+
+        def types_in_branch(branch)
+          branch = branch.children.first if branch.method?(:!)
+
+          if branch.method?(:type?)
+            branch.arguments.map(&:value)
+          elsif branch.method?(:defined_type?)
+            # `node.defined_type?` relates to `node.type == :defined?`
+            'defined?'
+          else
+            branch.method_name.to_s.delete_suffix('_type?')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_source_range.rb

@@ -59,6 +59,7 @@ module RuboCop
 
         def on_send(node)
           return unless (source_range = redundant_source_range(node))
+          return unless source_range.receiver
           return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
 
           selector = source_range.loc.selector

data/lib/rubocop/cop/internal_affairs.rb

@@ -15,6 +15,8 @@ require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
+require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Bare access modifiers (those not applying to specific methods) should be
-      # indented as deep as method definitions, or as deep as the class/module
+      # indented as deep as method definitions, or as deep as the `class`/`module`
       # keyword, depending on configuration.
       #
       # @example EnforcedStyle: indent (default)

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -188,7 +188,7 @@ module RuboCop
         # In offense message, we want to show the assignment LHS rather than
         # the entire assignment.
         def find_lhs_node(node)
-          node = node.lhs while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end
 

data/lib/rubocop/cop/layout/class_structure.rb

@@ -236,7 +236,7 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.def_type? || class_def.send_type?
+          if class_def.type?(:def, :send)
             [class_def]
           else
             class_def.children.compact
@@ -289,7 +289,7 @@ module RuboCop
         def marked_as_private_constant?(node, name)
           return false unless node.method?(:private_constant)
 
-          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
         end
 
         def end_position_for(node)

data/lib/rubocop/cop/layout/dot_position.rb

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def end_range(node)

data/lib/rubocop/cop/layout/else_alignment.rb

@@ -92,7 +92,7 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block
+          when :block, :numblock
             assignment_node = assignment_node(parent)
             if same_line?(parent, assignment_node)
               assignment_node.source_range