rubocop-ast 1.23.0 → 1.31.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfec7f927c495d16f847400f123da08ff90e6a94ff6319a84ce21fb0b261b7a5
-  data.tar.gz: c770260ba7f50b0bb233d8e95d43e1d8fa1674a2a11af4548a37f919b5ce9cc8
+  metadata.gz: 56067f459b491d4b3f10deb7f4d198b5ad9cffbc52739a53dec9d3b644c6b8a6
+  data.tar.gz: d45cf7be143799cea97c0af7c35e05d8ccdc7b5fc920ba05d2504bb1eacb745f
 SHA512:
-  metadata.gz: efbc6b544362492884000f55fbb1b216c6f4e55bb1087c88e3218bb595f91129afd4c45ecaa3e3d02784d7cd714ad21765c376aaad5e0768917384c366657e48
-  data.tar.gz: 7f98a811c53a27eba7211f05b6a368b7f058dd285e6771c7ed2d97230688e88498c6f57b1d7e585ff83b5f0d3f85b928bb67ba4bbbeaa06fa7c0eb5aa7e5d20a
+  metadata.gz: c7f375ab38218879cf28118dd9b8144f2ce00832dc13aa6d23338adefaf531fbae4af141b9a9b1332a402b1d1c6e9105a1fe45ba1afe18c971aee0a713f2b695
+  data.tar.gz: 3d01a913bb5e333f8e605492574b2492238cf1208bac5b6a0fc0e880e76e0be391a6bf187c51ebdafbbef35f2702255b166cfe85e6a9ce7d0cedc4a868938c91

data/lib/rubocop/ast/builder.rb

@@ -19,76 +19,77 @@ module RuboCop
 
       # @api private
       NODE_MAP = {
-        and:          AndNode,
-        and_asgn:     AndAsgnNode,
-        alias:        AliasNode,
-        arg:          ArgNode,
-        blockarg:     ArgNode,
-        forward_arg:  ArgNode,
-        kwarg:        ArgNode,
-        kwoptarg:     ArgNode,
-        kwrestarg:    ArgNode,
-        optarg:       ArgNode,
-        restarg:      ArgNode,
-        shadowarg:    ArgNode,
-        args:         ArgsNode,
-        array:        ArrayNode,
-        lvasgn:       AsgnNode,
-        ivasgn:       AsgnNode,
-        cvasgn:       AsgnNode,
-        gvasgn:       AsgnNode,
-        block:        BlockNode,
-        numblock:     BlockNode,
-        break:        BreakNode,
-        case_match:   CaseMatchNode,
-        casgn:        CasgnNode,
-        case:         CaseNode,
-        class:        ClassNode,
-        const:        ConstNode,
-        def:          DefNode,
-        defined?:     DefinedNode,
-        defs:         DefNode,
-        dstr:         DstrNode,
-        ensure:       EnsureNode,
-        for:          ForNode,
-        forward_args: ForwardArgsNode,
-        float:        FloatNode,
-        hash:         HashNode,
-        if:           IfNode,
-        in_pattern:   InPatternNode,
-        int:          IntNode,
-        index:        IndexNode,
-        indexasgn:    IndexasgnNode,
-        irange:       RangeNode,
-        erange:       RangeNode,
-        kwargs:       HashNode,
-        kwsplat:      KeywordSplatNode,
-        lambda:       LambdaNode,
-        module:       ModuleNode,
-        next:         NextNode,
-        op_asgn:      OpAsgnNode,
-        or_asgn:      OrAsgnNode,
-        or:           OrNode,
-        pair:         PairNode,
-        procarg0:     Procarg0Node,
-        regexp:       RegexpNode,
-        rescue:       RescueNode,
-        resbody:      ResbodyNode,
-        return:       ReturnNode,
-        csend:        SendNode,
-        send:         SendNode,
-        str:          StrNode,
-        xstr:         StrNode,
-        sclass:       SelfClassNode,
-        super:        SuperNode,
-        zsuper:       SuperNode,
-        sym:          SymbolNode,
-        until:        UntilNode,
-        until_post:   UntilNode,
-        when:         WhenNode,
-        while:        WhileNode,
-        while_post:   WhileNode,
-        yield:        YieldNode
+        and:                 AndNode,
+        and_asgn:            AndAsgnNode,
+        alias:               AliasNode,
+        arg:                 ArgNode,
+        blockarg:            ArgNode,
+        forward_arg:         ArgNode,
+        kwarg:               ArgNode,
+        kwoptarg:            ArgNode,
+        kwrestarg:           ArgNode,
+        optarg:              ArgNode,
+        restarg:             ArgNode,
+        shadowarg:           ArgNode,
+        args:                ArgsNode,
+        array:               ArrayNode,
+        lvasgn:              AsgnNode,
+        ivasgn:              AsgnNode,
+        cvasgn:              AsgnNode,
+        gvasgn:              AsgnNode,
+        block:               BlockNode,
+        numblock:            BlockNode,
+        break:               BreakNode,
+        case_match:          CaseMatchNode,
+        casgn:               CasgnNode,
+        case:                CaseNode,
+        class:               ClassNode,
+        const:               ConstNode,
+        def:                 DefNode,
+        defined?:            DefinedNode,
+        defs:                DefNode,
+        dstr:                DstrNode,
+        ensure:              EnsureNode,
+        for:                 ForNode,
+        forward_args:        ForwardArgsNode,
+        forwarded_kwrestarg: KeywordSplatNode,
+        float:               FloatNode,
+        hash:                HashNode,
+        if:                  IfNode,
+        in_pattern:          InPatternNode,
+        int:                 IntNode,
+        index:               IndexNode,
+        indexasgn:           IndexasgnNode,
+        irange:              RangeNode,
+        erange:              RangeNode,
+        kwargs:              HashNode,
+        kwsplat:             KeywordSplatNode,
+        lambda:              LambdaNode,
+        module:              ModuleNode,
+        next:                NextNode,
+        op_asgn:             OpAsgnNode,
+        or_asgn:             OrAsgnNode,
+        or:                  OrNode,
+        pair:                PairNode,
+        procarg0:            Procarg0Node,
+        regexp:              RegexpNode,
+        rescue:              RescueNode,
+        resbody:             ResbodyNode,
+        return:              ReturnNode,
+        csend:               CsendNode,
+        send:                SendNode,
+        str:                 StrNode,
+        xstr:                StrNode,
+        sclass:              SelfClassNode,
+        super:               SuperNode,
+        zsuper:              SuperNode,
+        sym:                 SymbolNode,
+        until:               UntilNode,
+        until_post:          UntilNode,
+        when:                WhenNode,
+        while:               WhileNode,
+        while_post:          WhileNode,
+        yield:               YieldNode
       }.freeze
 
       # Generates {Node} from the given information.

data/lib/rubocop/ast/ext/range.rb

@@ -15,8 +15,8 @@ module RuboCop
         #     :bar
         #   ]
         #
-        #   node.loc.begin.line_span                         # => 1..1
-        #   node.loc.expression.line_span(exclude_end: true) # => 1...4
+        #   node.loc.begin.line_span                       # => 1..1
+        #   node.source_range.line_span(exclude_end: true) # => 1...4
         def line_span(exclude_end: false)
           ::Range.new(first_line, last_line, exclude_end)
         end
@@ -25,4 +25,4 @@ module RuboCop
   end
 end
 
-::Parser::Source::Range.include ::RuboCop::AST::Ext::Range
+Parser::Source::Range.include RuboCop::AST::Ext::Range

data/lib/rubocop/ast/node/block_node.rb

@@ -21,6 +21,24 @@ module RuboCop
         node_parts[0]
       end
 
+      # A shorthand for getting the first argument of this block.
+      # Equivalent to `arguments.first`.
+      #
+      # @return [Node, nil] the first argument of this block,
+      #                     or `nil` if there are no arguments
+      def first_argument
+        arguments[0]
+      end
+
+      # A shorthand for getting the last argument of this block.
+      # Equivalent to `arguments.last`.
+      #
+      # @return [Node, nil] the last argument of this block,
+      #                     or `nil` if there are no arguments
+      def last_argument
+        arguments[-1]
+      end
+
       # The arguments of this block.
       # Note that if the block has destructured arguments, `arguments` will
       # return a `mlhs` node, whereas `argument_list` will return only

data/lib/rubocop/ast/node/csend_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `csend` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `csend` nodes within RuboCop.
+    class CsendNode < SendNode
+      def send_type?
+        false
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/if_node.rb

@@ -81,7 +81,7 @@ module RuboCop
         (if? || unless?) && super
       end
 
-      # Chacks whether the `if` node has nested `if` nodes in any of its
+      # Checks whether the `if` node has nested `if` nodes in any of its
       # branches.
       #
       # @note This performs a shallow search.

data/lib/rubocop/ast/node/keyword_splat_node.rb

@@ -2,9 +2,9 @@
 
 module RuboCop
   module AST
-    # A node extension for `kwsplat` nodes. This will be used in place of a
-    # plain  node when the builder constructs the AST, making its methods
-    # available to all `kwsplat` nodes within RuboCop.
+    # A node extension for `kwsplat` and `forwarded_kwrestarg` nodes. This will be used in
+    # place of a plain node when the builder constructs the AST, making its methods available to
+    # all `kwsplat` and `forwarded_kwrestarg` nodes within RuboCop.
     class KeywordSplatNode < Node
       include HashElementNode
 
@@ -41,6 +41,13 @@ module RuboCop
       def node_parts
         [self, self]
       end
+
+      # This provides `forwarded_kwrestarg` node to return true to be compatible with `kwsplat` node.
+      #
+      # @return [true]
+      def kwsplat_type?
+        true
+      end
     end
   end
 end

data/lib/rubocop/ast/node/mixin/descendence.rb

@@ -36,7 +36,10 @@ module RuboCop
       #
       # @return [Array<Node>] an array of child nodes
       def child_nodes
-        each_child_node.to_a
+        # Iterate child nodes directly to avoid allocating an Enumerator.
+        nodes = []
+        each_child_node { |node| nodes << node }
+        nodes
       end
 
       # Calls the given block for each descendant node with depth first order.
@@ -102,7 +105,9 @@ module RuboCop
       protected
 
       def visit_descendants(types, &block)
-        each_child_node do |child|
+        children.each do |child|
+          next unless child.is_a?(::AST::Node)
+
           yield child if types.empty? || types.include?(child.type)
           child.visit_descendants(types, &block)
         end

data/lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -5,7 +5,7 @@ module RuboCop
     # Common functionality for nodes that are a kind of method dispatch:
     # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`,
     # and (modern only): `index`, `indexasgn`, `lambda`
-    module MethodDispatchNode
+    module MethodDispatchNode # rubocop:disable Metrics/ModuleLength
       extend NodePattern::Macros
       include MethodIdentifierPredicates
 
@@ -28,6 +28,17 @@ module RuboCop
         node_parts[1]
       end
 
+      # The source range for the method name or keyword that dispatches this call.
+      #
+      # @return [Parser::Source::Range] the source range for the method name or keyword
+      def selector
+        if loc.respond_to? :keyword
+          loc.keyword
+        else
+          loc.selector
+        end
+      end
+
       # The `block` or `numblock` node associated with this method dispatch, if any.
       #
       # @return [BlockNode, nil] the `block` or `numblock` node associated with this method
@@ -147,7 +158,7 @@ module RuboCop
       #
       # @return [Boolean] whether the method is the implicit form of `#call`
       def implicit_call?
-        method?(:call) && !loc.selector
+        method?(:call) && !selector
       end
 
       # Whether this method dispatch has an explicit block.
@@ -211,7 +222,7 @@ module RuboCop
       #
       # @return [Boolean] whether this method is a lambda literal
       def lambda_literal?
-        block_literal? && loc.expression && loc.expression.source == '->'
+        loc.expression.source == '->' && block_literal?
       end
 
       # Checks whether this is a unary operation.
@@ -222,9 +233,9 @@ module RuboCop
       #
       # @return [Boolean] whether this method is a unary operation
       def unary_operation?
-        return false unless loc.selector
+        return false unless selector
 
-        operator_method? && loc.expression.begin_pos == loc.selector.begin_pos
+        operator_method? && loc.expression.begin_pos == selector.begin_pos
       end
 
       # Checks whether this is a binary operation.
@@ -235,9 +246,9 @@ module RuboCop
       #
       # @return [Boolean] whether this method is a binary operation
       def binary_operation?
-        return false unless loc.selector
+        return false unless selector
 
-        operator_method? && loc.expression.begin_pos != loc.selector.begin_pos
+        operator_method? && loc.expression.begin_pos != selector.begin_pos
       end
 
       private

data/lib/rubocop/ast/node/mixin/parameterized_node.rb

@@ -82,9 +82,17 @@ module RuboCop
       # and optimizes other calls
       module RestArguments
         include ParameterizedNode
+
+        EMPTY_ARGUMENTS = [].freeze
+
         # @return [Array<Node>] arguments, if any
         def arguments
-          children[first_argument_index..].freeze
+          if arguments?
+            children.drop(first_argument_index).freeze
+          else
+            # Skip unneeded Array allocation.
+            EMPTY_ARGUMENTS
+          end
         end
 
         # A shorthand for getting the first argument of the node.

data/lib/rubocop/ast/node/send_node.rb

@@ -15,6 +15,10 @@ module RuboCop
          (_    _    _                                                 _ ...)]
       PATTERN
 
+      def send_type?
+        true
+      end
+
       private
 
       def first_argument_index

data/lib/rubocop/ast/node.rb

@@ -84,8 +84,12 @@ module RuboCop
       LITERAL_RECURSIVE_TYPES = (OPERATOR_KEYWORDS + COMPOSITE_LITERALS + %i[begin pair]).freeze
       private_constant :LITERAL_RECURSIVE_METHODS, :LITERAL_RECURSIVE_TYPES
 
+      EMPTY_CHILDREN = [].freeze
+      EMPTY_PROPERTIES = {}.freeze
+      private_constant :EMPTY_CHILDREN, :EMPTY_PROPERTIES
+
       # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
-      def initialize(type, children = [], properties = {})
+      def initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES)
         @mutable_attributes = {}
 
         # ::AST::Node#initialize freezes itself.
@@ -101,11 +105,19 @@ module RuboCop
         end
       end
 
-      Parser::Meta::NODE_TYPES.each do |node_type|
+      (Parser::Meta::NODE_TYPES - [:send]).each do |node_type|
         method_name = "#{node_type.to_s.gsub(/\W/, '')}_type?"
-        define_method(method_name) do
-          type == node_type
-        end
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}          # def block_type?
+            @type == :#{node_type}    #   @type == :block
+          end                         # end
+        RUBY
+      end
+
+      # Most nodes are of 'send' type, so this method is defined
+      # separately to make this check as fast as possible.
+      def send_type?
+        false
       end
 
       # Returns the parent node, or `nil` if the receiver is a root node.
@@ -203,9 +215,7 @@ module RuboCop
       # destructuring method.
       #
       # @return [Array<Node>] the different parts of the ndde
-      def node_parts
-        to_a
-      end
+      alias node_parts to_a
 
       # Calls the given block for each ancestor node from parent to root.
       # If no block is given, an `Enumerator` is returned.
@@ -316,13 +326,13 @@ module RuboCop
         # what class or module is this method/constant/etc definition in?
         # returns nil if answer cannot be determined
         ancestors = each_ancestor(:class, :module, :sclass, :casgn, :block)
-        result    = ancestors.map do |ancestor|
+        result    = ancestors.filter_map do |ancestor|
           parent_module_name_part(ancestor) do |full_name|
             return nil unless full_name
 
             full_name
           end
-        end.compact.reverse.join('::')
+        end.reverse.join('::')
         result.empty? ? 'Object' : result
       end
 
@@ -500,8 +510,14 @@ module RuboCop
 
       # @!method class_constructor?(node = self)
       def_node_matcher :class_constructor?, <<~PATTERN
-        {       (send #global_const?({:Class :Module :Struct}) :new ...)
-         (block (send #global_const?({:Class :Module :Struct}) :new ...) ...)}
+        {
+          (send #global_const?({:Class :Module :Struct}) :new ...)
+          (send #global_const?(:Data) :define ...)
+          ({block numblock} {
+            (send #global_const?({:Class :Module :Struct}) :new ...)
+            (send #global_const?(:Data) :define ...)
+          } ...)
+        }
       PATTERN
 
       # @deprecated Use `:class_constructor?`

data/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb

@@ -38,7 +38,7 @@ module RuboCop
           end
 
           def visit_set
-            set = node.children.map(&:child).to_set.freeze
+            set = node.children.to_set(&:child).freeze
             NodePattern::Sets[set]
           end
 

data/lib/rubocop/ast/node_pattern/compiler/debug.rb

@@ -47,7 +47,7 @@ module RuboCop
               # @return [String] a Rainbow colorized version of ruby
               def colorize(color_scheme = COLOR_SCHEME)
                 map = color_map(color_scheme)
-                ast.loc.expression.source_buffer.source.chars.map.with_index do |char, i|
+                ast.source_range.source_buffer.source.chars.map.with_index do |char, i|
                   Rainbow(char).color(map[i])
                 end.join
               end

data/lib/rubocop/ast/node_pattern/lexer.rex.rb

@@ -2,7 +2,7 @@
 # encoding: UTF-8
 #--
 # This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.6.0.
+# Generated by: oedipus_lex version 2.6.1.
 # Source: lib/rubocop/ast/node_pattern/lexer.rex
 #++
 

data/lib/rubocop/ast/node_pattern/node.rb

@@ -75,6 +75,10 @@ module RuboCop
           self.class.new(type, children, { location: location })
         end
 
+        def source_range
+          loc.expression
+        end
+
         INT_TO_RANGE = Hash.new { |h, k| h[k] = k..k }
         private_constant :INT_TO_RANGE
 
@@ -203,7 +207,7 @@ module RuboCop
           include ForbidInSeqHead
 
           def arity
-            min, max = children.map(&:arity_range).map(&:minmax).transpose.map(&:sum)
+            min, max = children.map { |child| child.arity_range.minmax }.transpose.map(&:sum)
             min == max ? min || 0 : min..max # NOTE: || 0 for empty case, where min == max == nil.
           end
 
@@ -219,7 +223,7 @@ module RuboCop
         # Node class for `{ ... }`
         class Union < Node
           def arity
-            minima, maxima = children.map(&:arity_range).map(&:minmax).transpose
+            minima, maxima = children.map { |child| child.arity_range.minmax }.transpose
             min = minima.min
             max = maxima.max
             min == max ? min : min..max

data/lib/rubocop/ast/node_pattern/parser.racc.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.5.1
+# This file is automatically generated by Racc 1.7.1
 # from Racc grammar file "".
 #
 
@@ -239,6 +239,7 @@ Racc_arg = [
   racc_shift_n,
   racc_reduce_n,
   racc_use_result_var ]
+Ractor.make_shareable(Racc_arg) if defined?(Ractor)
 
 Racc_token_to_s_table = [
   "$end",
@@ -289,6 +290,7 @@ Racc_token_to_s_table = [
   "opt_rest",
   "rest",
   "arg_list" ]
+Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
 
 Racc_debug_parser = false
 

data/lib/rubocop/ast/node_pattern/with_meta.rb

@@ -48,12 +48,12 @@ module RuboCop
 
             def emit_unary_op(type, operator_t = nil, *children)
               children[-1] = children[-1].first if children[-1].is_a?(Array) # token?
-              map = source_map(children.first.loc.expression, operator_t: operator_t)
+              map = source_map(children.first.source_range, operator_t: operator_t)
               n(type, children, map)
             end
 
             def emit_list(type, begin_t, children, end_t)
-              expr = children.first.loc.expression.join(children.last.loc.expression)
+              expr = children.first.source_range.join(children.last.source_range)
               map = source_map(expr, begin_t: begin_t, end_t: end_t)
               n(type, children, map)
             end
@@ -79,8 +79,7 @@ module RuboCop
             end
 
             def join_exprs(left_expr, right_expr)
-              left_expr.loc.expression
-                       .join(right_expr.loc.expression)
+              left_expr.source_range.join(right_expr.source_range)
             end
 
             def source_map(token_or_range, begin_t: nil, end_t: nil, operator_t: nil, selector_t: nil)

data/lib/rubocop/ast/node_pattern.rb

@@ -54,6 +54,22 @@ module RuboCop
 
       VAR = 'node'
 
+      # Yields its argument and any descendants, depth-first.
+      #
+      def self.descend(element, &block)
+        return to_enum(__method__, element) unless block
+
+        yield element
+
+        if element.is_a?(::RuboCop::AST::Node)
+          element.children.each do |child|
+            descend(child, &block)
+          end
+        end
+
+        nil
+      end
+
       attr_reader :pattern, :ast, :match_code
 
       def_delegators :@compiler, :captures, :named_parameters, :positional_parameters
@@ -100,22 +116,6 @@ module RuboCop
         initialize(coder['pattern'])
       end
 
-      # Yields its argument and any descendants, depth-first.
-      #
-      def self.descend(element, &block)
-        return to_enum(__method__, element) unless block
-
-        yield element
-
-        if element.is_a?(::RuboCop::AST::Node)
-          element.children.each do |child|
-            descend(child, &block)
-          end
-        end
-
-        nil
-      end
-
       def freeze
         @match_code.freeze
         @compiler.freeze

data/lib/rubocop/ast/processed_source.rb

@@ -12,30 +12,40 @@ module RuboCop
       # @api private
       STRING_SOURCE_NAME = '(string)'
 
+      INVALID_LEVELS = %i[error fatal].freeze
+      private_constant :INVALID_LEVELS
+
+      PARSER_ENGINES = %i[parser_whitequark parser_prism].freeze
+      private_constant :PARSER_ENGINES
+
       attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                  :parser_error, :raw_source, :ruby_version
+                  :parser_error, :raw_source, :ruby_version, :parser_engine
 
-      def self.from_file(path, ruby_version)
+      def self.from_file(path, ruby_version, parser_engine: :parser_whitequark)
         file = File.read(path, mode: 'rb')
-        new(file, ruby_version, path)
+        new(file, ruby_version, path, parser_engine: parser_engine)
       end
 
-      INVALID_LEVELS = %i[error fatal].freeze
-      private_constant :INVALID_LEVELS
+      def initialize(source, ruby_version, path = nil, parser_engine: :parser_whitequark)
+        parser_engine = parser_engine.to_sym
+        unless PARSER_ENGINES.include?(parser_engine)
+          raise ArgumentError, 'The keyword argument `parser_engine` accepts `parser_whitequark` ' \
+                               "or `parser_prism`, but `#{parser_engine}` was passed."
+        end
 
-      def initialize(source, ruby_version, path = nil)
         # Defaults source encoding to UTF-8, regardless of the encoding it has
         # been read with, which could be non-utf8 depending on the default
         # external encoding.
-        source.force_encoding(Encoding::UTF_8) unless source.encoding == Encoding::UTF_8
+        (+source).force_encoding(Encoding::UTF_8) unless source.encoding == Encoding::UTF_8
 
         @raw_source = source
         @path = path
         @diagnostics = []
         @ruby_version = ruby_version
+        @parser_engine = parser_engine
         @parser_error = nil
 
-        parse(source, ruby_version)
+        parse(source, ruby_version, parser_engine)
       end
 
       def ast_with_comments
@@ -193,13 +203,13 @@ module RuboCop
         end
       end
 
-      def parse(source, ruby_version)
+      def parse(source, ruby_version, parser_engine)
         buffer_name = @path || STRING_SOURCE_NAME
         @buffer = Parser::Source::Buffer.new(buffer_name, 1)
 
         begin
           @buffer.source = source
-        rescue EncodingError => e
+        rescue EncodingError, Parser::UnknownEncodingInMagicComment => e
           @parser_error = e
           @ast = nil
           @comments = []
@@ -207,7 +217,7 @@ module RuboCop
           return
         end
 
-        @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
+        @ast, @comments, @tokens = tokenize(create_parser(ruby_version, parser_engine))
       end
 
       def tokenize(parser)
@@ -227,55 +237,82 @@ module RuboCop
       end
 
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      def parser_class(ruby_version)
-        case ruby_version
-        when 1.9
-          require 'parser/ruby19'
-          Parser::Ruby19
-        when 2.0
-          require 'parser/ruby20'
-          Parser::Ruby20
-        when 2.1
-          require 'parser/ruby21'
-          Parser::Ruby21
-        when 2.2
-          require 'parser/ruby22'
-          Parser::Ruby22
-        when 2.3
-          require 'parser/ruby23'
-          Parser::Ruby23
-        when 2.4
-          require 'parser/ruby24'
-          Parser::Ruby24
-        when 2.5
-          require 'parser/ruby25'
-          Parser::Ruby25
-        when 2.6
-          require 'parser/ruby26'
-          Parser::Ruby26
-        when 2.7
-          require 'parser/ruby27'
-          Parser::Ruby27
-        when 2.8, 3.0
-          require 'parser/ruby30'
-          Parser::Ruby30
-        when 3.1
-          require 'parser/ruby31'
-          Parser::Ruby31
-        when 3.2
-          require 'parser/ruby32'
-          Parser::Ruby32
-        else
-          raise ArgumentError,
-                "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
+      def parser_class(ruby_version, parser_engine)
+        case parser_engine
+        when :parser_whitequark
+          case ruby_version
+          when 1.9
+            require 'parser/ruby19'
+            Parser::Ruby19
+          when 2.0
+            require 'parser/ruby20'
+            Parser::Ruby20
+          when 2.1
+            require 'parser/ruby21'
+            Parser::Ruby21
+          when 2.2
+            require 'parser/ruby22'
+            Parser::Ruby22
+          when 2.3
+            require 'parser/ruby23'
+            Parser::Ruby23
+          when 2.4
+            require 'parser/ruby24'
+            Parser::Ruby24
+          when 2.5
+            require 'parser/ruby25'
+            Parser::Ruby25
+          when 2.6
+            require 'parser/ruby26'
+            Parser::Ruby26
+          when 2.7
+            require 'parser/ruby27'
+            Parser::Ruby27
+          when 2.8, 3.0
+            require 'parser/ruby30'
+            Parser::Ruby30
+          when 3.1
+            require 'parser/ruby31'
+            Parser::Ruby31
+          when 3.2
+            require 'parser/ruby32'
+            Parser::Ruby32
+          when 3.3
+            require 'parser/ruby33'
+            Parser::Ruby33
+          when 3.4
+            require 'parser/ruby34'
+            Parser::Ruby34
+          else
+            raise ArgumentError, "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
+          end
+        when :parser_prism
+          begin
+            require 'prism'
+          rescue LoadError
+            warn "Error: Unable to load Prism. Add `gem 'prism'` to your Gemfile."
+            exit!
+          end
+
+          case ruby_version
+          when 3.3
+            require 'prism/translation/parser33'
+            Prism::Translation::Parser33
+          when 3.4
+            require 'prism/translation/parser34'
+            Prism::Translation::Parser34
+          else
+            raise ArgumentError, 'RuboCop supports target Ruby versions 3.3 and above with Prism. ' \
+                                 "Specified target Ruby version: #{ruby_version.inspect}"
+          end
         end
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-      def create_parser(ruby_version)
+      def create_parser(ruby_version, parser_engine)
         builder = RuboCop::AST::Builder.new
 
-        parser_class(ruby_version).new(builder).tap do |parser|
+        parser_class(ruby_version, parser_engine).new(builder).tap do |parser|
           # On JRuby there's a risk that we hang in tokenize() if we
           # don't set the all errors as fatal flag. The problem is caused by a bug
           # in Racc that is discussed in issue #93 of the whitequark/parser

data/lib/rubocop/ast/sexp.rb

@@ -9,7 +9,8 @@ module RuboCop
     module Sexp
       # Creates a {Node} with type `type` and children `children`.
       def s(type, *children)
-        Node.new(type, children)
+        klass = Builder::NODE_MAP[type] || Node
+        klass.new(type, children)
       end
     end
   end

data/lib/rubocop/ast/token.rb

@@ -4,6 +4,8 @@ module RuboCop
   module AST
     # A basic wrapper around Parser's tokens.
     class Token
+      LEFT_PAREN_TYPES = %i[tLPAREN tLPAREN2].freeze
+
       attr_reader :pos, :type, :text
 
       def self.from_parser_token(parser_token)
@@ -81,7 +83,7 @@ module RuboCop
       end
 
       def left_curly_brace?
-        type == :tLCURLY
+        type == :tLCURLY || type == :tLAMBEG
       end
 
       def right_curly_brace?
@@ -89,7 +91,7 @@ module RuboCop
       end
 
       def left_parens?
-        %i[tLPAREN tLPAREN2].include?(type)
+        LEFT_PAREN_TYPES.include?(type)
       end
 
       def right_parens?

data/lib/rubocop/ast/traversal.rb

@@ -38,14 +38,14 @@ module RuboCop
                          body: self.body(signature, arity_check))
           type, *aliases = type
           lineno = caller_locations(1, 1).first.lineno
-          module_eval(<<~RUBY, __FILE__, lineno) # rubocop:disable Style/EvalWithLocation
+          module_eval(<<~RUBY, __FILE__, lineno)
             def on_#{type}(node)        # def on_send(node)
               #{body}                   #   # body ...
               nil                       #   nil
             end                         # end
           RUBY
           aliases.each do |m|
-            alias_method "on_#{m}", "on_#{type}"
+            alias_method :"on_#{m}", :"on_#{type}"
           end
         end
 
@@ -75,7 +75,8 @@ module RuboCop
       ### arity == 0
       no_children = %i[true false nil self cbase zsuper redo retry
                        forward_args forwarded_args match_nil_pattern
-                       forward_arg lambda empty_else kwnilarg
+                       forward_arg forwarded_restarg forwarded_kwrestarg
+                       lambda empty_else kwnilarg
                        __FILE__ __LINE__ __ENCODING__]
 
       ### arity == 0..1

data/lib/rubocop/ast/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module AST
     module Version
-      STRING = '1.23.0'
+      STRING = '1.31.3'
     end
   end
 end

data/lib/rubocop/ast.rb

@@ -76,6 +76,7 @@ require_relative 'ast/node/resbody_node'
 require_relative 'ast/node/return_node'
 require_relative 'ast/node/self_class_node'
 require_relative 'ast/node/send_node'
+require_relative 'ast/node/csend_node'
 require_relative 'ast/node/str_node'
 require_relative 'ast/node/dstr_node'
 require_relative 'ast/node/super_node'
@@ -91,5 +92,5 @@ require_relative 'ast/token'
 require_relative 'ast/traversal'
 require_relative 'ast/version'
 
-::RuboCop::AST::NodePattern::Parser.autoload :WithMeta, "#{__dir__}/ast/node_pattern/with_meta"
-::RuboCop::AST::NodePattern::Compiler.autoload :Debug, "#{__dir__}/ast/node_pattern/compiler/debug"
+RuboCop::AST::NodePattern::Parser.autoload :WithMeta, "#{__dir__}/ast/node_pattern/with_meta"
+RuboCop::AST::NodePattern::Compiler.autoload :Debug, "#{__dir__}/ast/node_pattern/compiler/debug"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-ast
 version: !ruby/object:Gem::Version
-  version: 1.23.0
+  version: 1.31.3
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-21 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -18,34 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.1.0
+        version: 3.3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.1.0
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.15.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.3.1.0
 description: "    RuboCop's Node and NodePattern classes.\n"
 email: rubocop@googlegroups.com
 executables: []
@@ -76,6 +56,7 @@ files:
 - lib/rubocop/ast/node/casgn_node.rb
 - lib/rubocop/ast/node/class_node.rb
 - lib/rubocop/ast/node/const_node.rb
+- lib/rubocop/ast/node/csend_node.rb
 - lib/rubocop/ast/node/def_node.rb
 - lib/rubocop/ast/node/defined_node.rb
 - lib/rubocop/ast/node/dstr_node.rb
@@ -168,14 +149,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: RuboCop tools to deal with Ruby code AST.