danger-packwerk 0.7.0 → 0.7.1

data/sorbet/rbi/gems/rubocop-ast@1.21.0.rbi

@@ -0,0 +1,4193 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-ast` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop-ast`.
+
+module RuboCop; end
+
+# ...
+module RuboCop::AST
+  extend ::RuboCop::AST::RuboCopCompatibility
+end
+
+# A node extension for `alias` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `alias` nodes within RuboCop.
+class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
+  # Returns the new identifier as specified by the `alias`.
+  #
+  # @return [SymbolNode] the new identifier
+  def new_identifier; end
+
+  # Returns the old identifier as specified by the `alias`.
+  #
+  # @return [SymbolNode] the old identifier
+  def old_identifier; end
+end
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  def operator; end
+end
+
+# A node extension for `until` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `until` nodes within RuboCop.
+class RuboCop::AST::AndNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+
+  # Returns the alternate operator of the `and` as a string.
+  # Returns `and` for `&&` and vice versa.
+  #
+  # @return [String] the alternate of the `and` operator
+  def alternate_operator; end
+
+  # Returns the inverse keyword of the `and` node as a string.
+  # Returns `||` for `&&` and `or` for `and`.
+  #
+  # @return [String] the inverse of the `and` operator
+  def inverse_operator; end
+end
+
+# A node extension for `arg`, `optarg`, `restarg`, `kwarg`, `kwoptarg`,
+# `kwrestarg`, `blockarg`, `shadowarg` and `forward_arg` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all `arg` nodes within RuboCop.
+class RuboCop::AST::ArgNode < ::RuboCop::AST::Node
+  # Checks whether the argument has a default value
+  #
+  # @return [Boolean] whether the argument has a default value
+  def default?; end
+
+  # Returns the default value of the argument, if any.
+  #
+  # @return [Node, nil] the default value of the argument
+  def default_value; end
+
+  # Returns the name of an argument.
+  #
+  # @return [Symbol, nil] the name of the argument
+  def name; end
+end
+
+# A node extension for `args` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `args` nodes within RuboCop.
+class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::CollectionNode
+
+  # Yield each argument from the collection.
+  # Arguments can be inside `mlhs` nodes in the case of destructuring, so this
+  # flattens the collection to just `arg`, `optarg`, `restarg`, `kwarg`,
+  # `kwoptarg`, `kwrestarg`, `blockarg`, `forward_arg` and `shadowarg`.
+  #
+  # @return [Array<Node>] array of argument nodes.
+  def argument_list; end
+
+  # It returns true if arguments are empty and delimiters do not exist.
+  # @example:
+  #   # true
+  #   def x; end
+  #   x { }
+  #   -> {}
+  #
+  #   # false
+  #   def x(); end
+  #   def x a; end
+  #   x { || }
+  #   -> () {}
+  #   -> a {}
+  #
+  # @return [Boolean]
+  def empty_and_without_delimiters?; end
+end
+
+# A node extension for `array` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `array` nodes within RuboCop.
+class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
+  # Checks whether the `array` literal is delimited by either percent or
+  # square brackets
+  #
+  # brackets
+  #
+  # @return [Boolean] whether the array is enclosed in percent or square
+  def bracketed?; end
+
+  # @deprecated Use `values.each` (a.k.a. `children.each`)
+  def each_value(&block); end
+
+  # Checks whether the `array` literal is delimited by percent brackets.
+  #
+  # @overload percent_literal?
+  # @overload percent_literal?
+  # @return [Boolean] whether the array is enclosed in percent brackets
+  def percent_literal?(type = T.unsafe(nil)); end
+
+  # Checks whether the `array` literal is delimited by square brackets.
+  #
+  # @return [Boolean] whether the array is enclosed in square brackets
+  def square_brackets?; end
+
+  # Returns an array of all value nodes in the `array` literal.
+  #
+  # @return [Array<Node>] an array of value nodes
+  def values; end
+end
+
+RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `lvasgn`, `ivasgn`, `cvasgn`, and `gvasgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  def expression; end
+
+  # The name of the variable being assigned as a symbol.
+  #
+  # @return [Symbol] the name of the variable being assigned
+  def name; end
+end
+
+# Common functionality for primitive literal nodes: `sym`, `str`,
+# `int`, `float`, ...
+module RuboCop::AST::BasicLiteralNode
+  # Returns the value of the literal.
+  #
+  # @return [mixed] the value of the literal
+  def value; end
+end
+
+# Common functionality for nodes that are binary operations:
+# `or`, `and` ...
+module RuboCop::AST::BinaryOperatorNode
+  # Returns all of the conditions, including nested conditions,
+  # of the binary operation.
+  #
+  # operation and the let and right hand side of any nested binary
+  # operators
+  #
+  # @return [Array<Node>] the left and right hand side of the binary
+  def conditions; end
+
+  # Returns the left hand side node of the binary operation.
+  #
+  # @return [Node] the left hand side of the binary operation
+  def lhs; end
+
+  # Returns the right hand side node of the binary operation.
+  #
+  # @return [Node] the right hand side of the binary operation
+  def rhs; end
+end
+
+# A node extension for `block` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `send` nodes within RuboCop.
+#
+# A `block` node is essentially a method send with a block. Parser nests
+# the `send` node inside the `block` node.
+class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::MethodIdentifierPredicates
+
+  # Returns a collection of all descendants of this node that are
+  # argument type nodes. See `ArgsNode#argument_list` for details.
+  #
+  # @return [Array<Node>]
+  def argument_list; 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
+  # actual argument nodes.
+  #
+  # @return [Array<Node>]
+  def arguments; end
+
+  # Checks whether this block takes any arguments.
+  #
+  # @return [Boolean] whether this `block` node takes any arguments
+  def arguments?; end
+
+  # The body of this block.
+  #
+  # @return [Node, nil] the body of the `block` node or `nil`
+  def body; end
+
+  # Checks whether the `block` literal is delimited by curly braces.
+  #
+  # @return [Boolean] whether the `block` literal is enclosed in braces
+  def braces?; end
+
+  # The closing delimiter for this `block` literal.
+  #
+  # @return [String] the closing delimiter for the `block` literal
+  def closing_delimiter; end
+
+  # The delimiters for this `block` literal.
+  #
+  # @return [Array<String>] the delimiters for the `block` literal
+  def delimiters; end
+
+  # Checks whether the `block` literal is delimited by `do`-`end` keywords.
+  #
+  # @return [Boolean] whether the `block` literal is enclosed in `do`-`end`
+  def keywords?; end
+
+  # Checks whether this `block` literal belongs to a lambda.
+  #
+  # @return [Boolean] whether the `block` literal belongs to a lambda
+  def lambda?; end
+
+  # The name of the dispatched method as a symbol.
+  #
+  # @return [Symbol] the name of the dispatched method
+  def method_name; end
+
+  # Checks whether this is a multiline block. This is overridden here
+  # because the general version in `Node` does not work for `block` nodes.
+  #
+  # @return [Boolean] whether the `block` literal is on a several lines
+  def multiline?; end
+
+  # The opening delimiter for this `block` literal.
+  #
+  # @return [String] the opening delimiter for the `block` literal
+  def opening_delimiter; end
+
+  # The `send` node associated with this block.
+  #
+  # @return [SendNode] the `send` node associated with the `block` node
+  def send_node; end
+
+  # Checks whether this is a single line block. This is overridden here
+  # because the general version in `Node` does not work for `block` nodes.
+  #
+  # @return [Boolean] whether the `block` literal is on a single line
+  def single_line?; end
+
+  # Checks whether this node body is a void context.
+  #
+  # @return [Boolean] whether the `block` node body is a void context
+  def void_context?; end
+
+  private
+
+  # Numbered arguments of this `numblock`.
+  def numbered_arguments; end
+end
+
+RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)
+
+# A node extension for `break` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `break` nodes within RuboCop.
+class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser`
+# generate ASTs with {RuboCop::AST::Node}.
+#
+# @example
+#   buffer = Parser::Source::Buffer.new('(string)')
+#   buffer.source = 'puts :foo'
+#
+#   builder = RuboCop::AST::Builder.new
+#   require 'parser/ruby25'
+#   parser = Parser::Ruby25.new(builder)
+#   root_node = parser.parse(buffer)
+class RuboCop::AST::Builder < ::Parser::Builders::Default
+  # Generates {Node} from the given information.
+  #
+  # @return [Node] the generated node
+  def n(type, children, source_map); end
+
+  # TODO: Figure out what to do about literal encoding handling...
+  # More details here https://github.com/whitequark/parser/issues/283
+  def string_value(token); end
+
+  private
+
+  def node_klass(type); end
+end
+
+# @api private
+RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `case_match` nodes. This will be used in place of
+# a plain node when the builder constructs the AST, making its methods
+# available to all `case_match` nodes within RuboCop.
+class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # and the `else` (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the `in` branches
+  def branches; end
+
+  # @deprecated Use `in_pattern_branches.each`
+  def each_in_pattern(&block); end
+
+  # Checks whether this case statement has an `else` branch.
+  #
+  # @return [Boolean] whether the `case` statement has an `else` branch
+  def else?; end
+
+  # Returns the else branch of the `case` statement, if any.
+  #
+  # @return [Node] the else branch node of the `case` statement
+  # @return [EmptyElse] the empty else branch node of the `case` statement
+  # @return [nil] if the case statement does not have an else branch.
+  def else_branch; end
+
+  # Returns an array of all the `in` pattern branches in the `case` statement.
+  #
+  # @return [Array<InPatternNode>] an array of `in_pattern` nodes
+  def in_pattern_branches; end
+
+  # Returns the keyword of the `case` statement as a string.
+  #
+  # @return [String] the keyword of the `case` statement
+  def keyword; end
+end
+
+# A node extension for `case` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `case` nodes within RuboCop.
+class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # and the else (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the when branches
+  def branches; end
+
+  # @deprecated Use `when_branches.each`
+  def each_when(&block); end
+
+  # Checks whether this case statement has an `else` branch.
+  #
+  # @return [Boolean] whether the `case` statement has an `else` branch
+  def else?; end
+
+  # Returns the else branch of the `case` statement, if any.
+  #
+  # @return [Node] the else branch node of the `case` statement
+  # @return [nil] if the case statement does not have an else branch.
+  def else_branch; end
+
+  # Returns the keyword of the `case` statement as a string.
+  #
+  # @return [String] the keyword of the `case` statement
+  def keyword; end
+
+  # Returns an array of all the when branches in the `case` statement.
+  #
+  # @return [Array<WhenNode>] an array of `when` nodes
+  def when_branches; end
+end
+
+# A node extension for `casgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  def expression; end
+
+  # The name of the variable being assigned as a symbol.
+  #
+  # @return [Symbol] the name of the variable being assigned
+  def name; end
+
+  # The namespace of the constant being assigned.
+  #
+  # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+  def namespace; end
+end
+
+# A node extension for `class` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `class` nodes within RuboCop.
+class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
+  # The body of this `class` node.
+  #
+  # @return [Node, nil] the body of the class
+  def body; end
+
+  # The identifier for this `class` node.
+  #
+  # @return [Node] the identifier of the class
+  def identifier; end
+
+  # The parent class for this `class` node.
+  #
+  # @return [Node, nil] the parent class of the class
+  def parent_class; end
+end
+
+# A mixin that helps give collection nodes array polymorphism.
+module RuboCop::AST::CollectionNode
+  extend ::Forwardable
+
+  def &(*args, &block); end
+  def *(*args, &block); end
+  def +(*args, &block); end
+  def -(*args, &block); end
+  def <<(*args, &block); end
+  def [](*args, &block); end
+  def []=(*args, &block); end
+  def all?(*args, &block); end
+  def any?(*args, &block); end
+  def append(*args, &block); end
+  def assoc(*args, &block); end
+  def at(*args, &block); end
+  def bsearch(*args, &block); end
+  def bsearch_index(*args, &block); end
+  def chain(*args, &block); end
+  def chunk(*args, &block); end
+  def chunk_while(*args, &block); end
+  def clear(*args, &block); end
+  def collect(*args, &block); end
+  def collect!(*args, &block); end
+  def collect_concat(*args, &block); end
+  def combination(*args, &block); end
+  def compact(*args, &block); end
+  def compact!(*args, &block); end
+  def concat(*args, &block); end
+  def count(*args, &block); end
+  def cycle(*args, &block); end
+  def deconstruct(*args, &block); end
+  def delete(*args, &block); end
+  def delete_at(*args, &block); end
+  def delete_if(*args, &block); end
+  def detect(*args, &block); end
+  def difference(*args, &block); end
+  def dig(*args, &block); end
+  def drop(*args, &block); end
+  def drop_while(*args, &block); end
+  def each(*args, &block); end
+  def each_cons(*args, &block); end
+  def each_entry(*args, &block); end
+  def each_index(*args, &block); end
+  def each_slice(*args, &block); end
+  def each_with_index(*args, &block); end
+  def each_with_object(*args, &block); end
+  def empty?(*args, &block); end
+  def entries(*args, &block); end
+  def fetch(*args, &block); end
+  def fill(*args, &block); end
+  def filter(*args, &block); end
+  def filter!(*args, &block); end
+  def filter_map(*args, &block); end
+  def find(*args, &block); end
+  def find_all(*args, &block); end
+  def find_index(*args, &block); end
+  def first(*args, &block); end
+  def flat_map(*args, &block); end
+  def flatten(*args, &block); end
+  def flatten!(*args, &block); end
+  def grep(*args, &block); end
+  def grep_v(*args, &block); end
+  def group_by(*args, &block); end
+  def include?(*args, &block); end
+  def index(*args, &block); end
+  def inject(*args, &block); end
+  def insert(*args, &block); end
+  def intersection(*args, &block); end
+  def join(*args, &block); end
+  def keep_if(*args, &block); end
+  def last(*args, &block); end
+  def lazy(*args, &block); end
+  def length(*args, &block); end
+  def map(*args, &block); end
+  def map!(*args, &block); end
+  def max(*args, &block); end
+  def max_by(*args, &block); end
+  def member?(*args, &block); end
+  def min(*args, &block); end
+  def min_by(*args, &block); end
+  def minmax(*args, &block); end
+  def minmax_by(*args, &block); end
+  def none?(*args, &block); end
+  def one?(*args, &block); end
+  def pack(*args, &block); end
+  def partition(*args, &block); end
+  def permutation(*args, &block); end
+  def place(*args, &block); end
+  def pop(*args, &block); end
+  def prepend(*args, &block); end
+  def product(*args, &block); end
+  def push(*args, &block); end
+  def rassoc(*args, &block); end
+  def reduce(*args, &block); end
+  def reject(*args, &block); end
+  def reject!(*args, &block); end
+  def repeated_combination(*args, &block); end
+  def repeated_permutation(*args, &block); end
+  def replace(*args, &block); end
+  def reverse(*args, &block); end
+  def reverse!(*args, &block); end
+  def reverse_each(*args, &block); end
+  def rindex(*args, &block); end
+  def rotate(*args, &block); end
+  def rotate!(*args, &block); end
+  def sample(*args, &block); end
+  def select(*args, &block); end
+  def select!(*args, &block); end
+  def shelljoin(*args, &block); end
+  def shift(*args, &block); end
+  def shuffle(*args, &block); end
+  def shuffle!(*args, &block); end
+  def size(*args, &block); end
+  def slice(*args, &block); end
+  def slice!(*args, &block); end
+  def slice_after(*args, &block); end
+  def slice_before(*args, &block); end
+  def slice_when(*args, &block); end
+  def sort(*args, &block); end
+  def sort!(*args, &block); end
+  def sort_by(*args, &block); end
+  def sort_by!(*args, &block); end
+  def sum(*args, &block); end
+  def take(*args, &block); end
+  def take_while(*args, &block); end
+  def tally(*args, &block); end
+  def to_ary(*args, &block); end
+  def to_default_s(*args, &block); end
+  def to_formatted_s(*args, &block); end
+  def to_fs(*args, &block); end
+  def to_h(*args, &block); end
+  def to_sentence(*args, &block); end
+  def to_set(*args, &block); end
+  def to_xml(*args, &block); end
+  def transpose(*args, &block); end
+  def union(*args, &block); end
+  def uniq(*args, &block); end
+  def uniq!(*args, &block); end
+  def unshift(*args, &block); end
+  def values_at(*args, &block); end
+  def zip(*args, &block); end
+  def |(*args, &block); end
+end
+
+RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
+
+# Common functionality for nodes that have conditions:
+# `if`, `while`, `until`, `case`.
+# This currently doesn't include `when` nodes, because they have multiple
+# conditions, and need to be checked for that.
+module RuboCop::AST::ConditionalNode
+  # Returns the body associated with the condition. This works together with
+  # each node's custom destructuring method to select the correct part of
+  # the node.
+  #
+  # @note For `if` nodes, this is the truthy branch.
+  # @return [Node, nil] the body of the node
+  def body; end
+
+  # Returns the condition of the node. This works together with each node's
+  # custom destructuring method to select the correct part of the node.
+  #
+  # @return [Node, nil] the condition of the node
+  def condition; end
+
+  # Checks whether the condition of the node is written on more than
+  # one line.
+  #
+  # @return [Boolean] whether the condition is on more than one line
+  def multiline_condition?; end
+
+  # Checks whether the condition of the node is written on a single line.
+  #
+  # @return [Boolean] whether the condition is on a single line
+  def single_line_condition?; end
+end
+
+# A node extension for `const` nodes.
+class RuboCop::AST::ConstNode < ::RuboCop::AST::Node
+  # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+  def absolute?; end
+
+  # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+  #   Note: some classes might have uppercase in which case this method
+  #   returns false
+  def class_name?; end
+
+  # Yield nodes for the namespace
+  #
+  #   For `::Foo::Bar::BAZ` => yields:
+  #      s(:cbase), then
+  #      s(:const, :Foo), then
+  #      s(:const, s(:const, :Foo), :Bar)
+  def each_path(&block); end
+
+  # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+  #   Note: some classes might have uppercase in which case this method
+  #   returns false
+  def module_name?; end
+
+  # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+  def namespace; end
+
+  # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+  def relative?; end
+
+  # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+  def short_name; end
+end
+
+# A node extension for `def` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `def` nodes within RuboCop.
+class RuboCop::AST::DefNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+
+  # Checks whether this method definition node forwards its arguments
+  # as per the feature added in Ruby 2.7.
+  #
+  # @note This is written in a way that may support lead arguments
+  #   which are rumored to be added in a later version of Ruby.
+  # @return [Boolean] whether the `def` node uses argument forwarding
+  def argument_forwarding?; end
+
+  # An array containing the arguments of the method definition.
+  #
+  # @return [Array<Node>] the arguments of the method definition
+  def arguments; end
+
+  # The body of the method definition.
+  #
+  # @note this can be either a `begin` node, if the method body contains
+  #   multiple expressions, or any other node, if it contains a single
+  #   expression.
+  # @return [Node] the body of the method definition
+  def body; end
+
+  # @return [Boolean] if the definition is without an `end` or not.
+  def endless?; end
+
+  # The name of the defined method as a symbol.
+  #
+  # @return [Symbol] the name of the defined method
+  def method_name; end
+
+  # The receiver of the method definition, if any.
+  #
+  # @return [Node, nil] the receiver of the method definition, or `nil`.
+  def receiver; end
+
+  # Checks whether this node body is a void context.
+  #
+  # @return [Boolean] whether the `def` node body is a void context
+  def void_context?; end
+end
+
+# A node extension for `defined?` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `send` nodes within RuboCop.
+class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  def arguments; end
+  def node_parts; end
+end
+
+# Common functionality for primitive literal nodes: `sym`, `str`,
+# `int`, `float`, ...
+module RuboCop::AST::Descendence
+  # Returns an array of child nodes.
+  # This is a shorthand for `node.each_child_node.to_a`.
+  #
+  # @return [Array<Node>] an array of child nodes
+  def child_nodes; end
+
+  # Returns an array of descendant nodes.
+  # This is a shorthand for `node.each_descendant.to_a`.
+  #
+  # @return [Array<Node>] an array of descendant nodes
+  def descendants; end
+
+  # Calls the given block for each child node.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # Note that this is different from `node.children.each { |child| ... }`
+  # which yields all children including non-node elements.
+  #
+  # @overload each_child_node
+  # @overload each_child_node
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each child node
+  def each_child_node(*types); end
+
+  # Calls the given block for each descendant node with depth first order.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @overload each_descendant
+  # @overload each_descendant
+  # @overload each_descendant
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each descendant node
+  def each_descendant(*types, &block); end
+
+  # Calls the given block for the receiver and each descendant node in
+  # depth-first order.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # This method would be useful when you treat the receiver node as the root
+  # of a tree and want to iterate over all nodes in the tree.
+  #
+  # @overload each_node
+  # @overload each_node
+  # @overload each_node
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each node
+  def each_node(*types, &block); end
+
+  protected
+
+  def visit_descendants(types, &block); end
+end
+
+# A node extension for `dstr` nodes. This will be used
+# in place of a plain node when the builder constructs the AST, making
+# its methods available to all `dstr` nodes within RuboCop.
+class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode
+  def value; end
+end
+
+# A node extension for `ensure` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `ensure` nodes within RuboCop.
+class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
+  # Returns the body of the `ensure` clause.
+  #
+  # @return [Node, nil] The body of the `ensure`.
+  def body; end
+end
+
+module RuboCop::AST::Ext; end
+
+# Extensions to Parser::AST::Range
+module RuboCop::AST::Ext::Range
+  # If `exclude_end` is `true`, then the range will be exclusive.
+  #
+  # Assume that `node` corresponds to the following array literal:
+  #
+  #   [
+  #     :foo,
+  #     :bar
+  #   ]
+  #
+  #   node.loc.begin.line_span                         # => 1..1
+  #   node.loc.expression.line_span(exclude_end: true) # => 1...4
+  #
+  # @return [Range] the range of line numbers for the node
+  def line_span(exclude_end: T.unsafe(nil)); end
+end
+
+# Refinement to circumvent broken `Range#minmax` for infinity ranges in 2.6-
+module RuboCop::AST::Ext::RangeMinMax; end
+
+# A node extension for `float` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available to
+# all `float` nodes within RuboCop.
+class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+  include ::RuboCop::AST::NumericNode
+end
+
+# A node extension for `for` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `for` nodes within RuboCop.
+class RuboCop::AST::ForNode < ::RuboCop::AST::Node
+  # Returns the body of the `for` loop.
+  #
+  # @return [Node, nil] The body of the `for` loop.
+  def body; end
+
+  # Returns the collection the `for` loop is iterating over.
+  #
+  # @return [Node] The collection the `for` loop is iterating over
+  def collection; end
+
+  # Checks whether the `for` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `for` node has a `do` keyword
+  def do?; end
+
+  # Returns the keyword of the `for` statement as a string.
+  #
+  # @return [String] the keyword of the `until` statement
+  def keyword; end
+
+  # Returns the iteration variable of the `for` loop.
+  #
+  # @return [Node] The iteration variable of the `for` loop
+  def variable; end
+
+  # Checks whether this node body is a void context.
+  # Always `true` for `for`.
+  #
+  # @return [true] whether the `for` node body is a void context
+  def void_context?; end
+end
+
+# A node extension for `forward-args` nodes. This will be used in place
+# of a plain node when the builder constructs the AST, making its methods
+# available to all `forward-args` nodes within RuboCop.
+#
+# Not used with modern emitters:
+#
+#   $ ruby-parse -e "def foo(...); end"
+#   (def :foo
+#     (args
+#       (forward-arg)) nil)
+#   $ ruby-parse --legacy -e "->(foo) { bar }"
+#   (def :foo
+#     (forward-args) nil)
+#
+# Note the extra 's' with legacy form.
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::CollectionNode
+
+  # Node wraps itself in an array to be compatible with other
+  # enumerable argument types.
+  def to_a; end
+end
+
+# Common functionality for nodes that can be used as hash elements:
+# `pair`, `kwsplat`
+module RuboCop::AST::HashElementNode
+  # Returns the delta between this element's delimiter and the argument's.
+  #
+  # @note Pairs with different delimiter styles return a delta of 0
+  # @return [Integer] the delta between the two delimiters
+  def delimiter_delta(other); end
+
+  # Returns the key of this `hash` element.
+  #
+  # @note For keyword splats, this returns the whole node
+  # @return [Node] the key of the hash element
+  def key; end
+
+  # Returns the delta between this pair's key and the argument pair's.
+  #
+  # @note Keys on the same line always return a delta of 0
+  # @note Keyword splats always return a delta of 0 for right alignment
+  # @param alignment [Symbol] whether to check the left or right side
+  # @return [Integer] the delta between the two keys
+  def key_delta(other, alignment = T.unsafe(nil)); end
+
+  # Checks whether this `hash` element is on the same line as `other`.
+  #
+  # @note A multiline element is considered to be on the same line if it
+  #   shares any of its lines with `other`
+  # @return [Boolean] whether this element is on the same line as `other`
+  def same_line?(other); end
+
+  # Returns the value of this `hash` element.
+  #
+  # @note For keyword splats, this returns the whole node
+  # @return [Node] the value of the hash element
+  def value; end
+
+  # Returns the delta between this element's value and the argument's.
+  #
+  # @note Keyword splats always return a delta of 0
+  # @return [Integer] the delta between the two values
+  def value_delta(other); end
+end
+
+# A helper class for comparing the positions of different parts of a
+# `pair` node.
+class RuboCop::AST::HashElementNode::HashElementDelta
+  # @raise [ArgumentError]
+  # @return [HashElementDelta] a new instance of HashElementDelta
+  def initialize(first, second); end
+
+  def delimiter_delta; end
+  def key_delta(alignment = T.unsafe(nil)); end
+  def value_delta; end
+
+  private
+
+  def delta(first, second, alignment = T.unsafe(nil)); end
+
+  # Returns the value of attribute first.
+  def first; end
+
+  # @return [Boolean]
+  def keyword_splat?; end
+
+  # Returns the value of attribute second.
+  def second; end
+
+  # @return [Boolean]
+  def valid_argument_types?; end
+end
+
+# A node extension for `hash` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `hash` nodes within RuboCop.
+class RuboCop::AST::HashNode < ::RuboCop::AST::Node
+  # Checks whether the `hash` literal is delimited by curly braces.
+  #
+  # @return [Boolean] whether the `hash` literal is enclosed in braces
+  def braces?; end
+
+  # Calls the given block for each `key` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  def each_key(&block); end
+
+  # Calls the given block for each `pair` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  def each_pair; end
+
+  # Calls the given block for each `value` node in the `hash` literal.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  def each_value(&block); end
+
+  # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes.
+  #
+  # @return[Boolean] whether the `hash` is empty
+  #
+  # @return [Boolean]
+  def empty?; end
+
+  # Returns an array of all the keys in the `hash` literal.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Array<Node>] an array of keys in the `hash` literal
+  def keys; end
+
+  # Checks whether this `hash` uses a mix of hash rocket and colon
+  # delimiters for its pairs.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Boolean] whether the `hash` uses mixed delimiters
+  def mixed_delimiters?; end
+
+  # Returns an array of all the key value pairs in the `hash` literal.
+  #
+  # ignored.
+  #
+  # @note this may be different from children as `kwsplat` nodes are
+  # @return [Array<PairNode>] an array of `pair` nodes
+  def pairs; end
+
+  # Checks whether any of the key value pairs in the `hash` literal are on
+  # the same line.
+  #
+  # @note A multiline `pair` is considered to be on the same line if it
+  #   shares any of its lines with another `pair`
+  # @note `kwsplat` nodes are ignored.
+  # @return [Boolean] whether any `pair` nodes are on the same line
+  def pairs_on_same_line?; end
+
+  # Returns an array of all the values in the `hash` literal.
+  #
+  # @note `kwsplat` nodes are ignored.
+  # @return [Array<Node>] an array of values in the `hash` literal
+  def values; end
+end
+
+# A node extension for `if` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `if` nodes within RuboCop.
+class RuboCop::AST::IfNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Returns an array of all the branches in the conditional statement.
+  #
+  # @return [Array<Node>] an array of branch nodes
+  def branches; end
+
+  # @deprecated Use `branches.each`
+  def each_branch(&block); end
+
+  # Checks whether the `if` node has an `else` clause.
+  #
+  # @note This returns `true` for nodes containing an `elsif` clause.
+  #   This is legacy behavior, and many cops rely on it.
+  # @return [Boolean] whether the node has an `else` clause
+  def else?; end
+
+  # Returns the branch of the `if` node that gets evaluated when its
+  # condition is falsey.
+  #
+  # @note This is normalized for `unless` nodes.
+  # @return [Node] the falsey branch node of the `if` node
+  # @return [nil] when there is no else branch
+  def else_branch; end
+
+  # Checks whether the `if` is an `elsif`. Parser handles these by nesting
+  # `if` nodes in the `else` branch.
+  #
+  # @return [Boolean] whether the node is an `elsif`
+  def elsif?; end
+
+  # Checks whether the `if` node has at least one `elsif` branch. Returns
+  # true if this `if` node itself is an `elsif`.
+  #
+  # @return [Boolean] whether the `if` node has at least one `elsif` branch
+  def elsif_conditional?; end
+
+  # Checks whether this node is an `if` statement. (This is not true of
+  # ternary operators and `unless` statements.)
+  #
+  # @return [Boolean] whether the node is an `if` statement
+  def if?; end
+
+  # Returns the branch of the `if` node that gets evaluated when its
+  # condition is truthy.
+  #
+  # @note This is normalized for `unless` nodes.
+  # @return [Node] the truthy branch node of the `if` node
+  # @return [nil] if the truthy branch is empty
+  def if_branch; end
+
+  # Returns the inverse keyword of the `if` node as a string. Returns `if`
+  # for `unless` nodes and vice versa. Returns an empty string for ternary
+  # operators.
+  #
+  # @return [String] the inverse keyword of the `if` statement
+  def inverse_keyword; end
+
+  # Returns the keyword of the `if` statement as a string. Returns an empty
+  # string for ternary operators.
+  #
+  # @return [String] the keyword of the `if` statement
+  def keyword; end
+
+  # Checks whether the `if` node is in a modifier form, i.e. a condition
+  # trailing behind an expression. Only `if` and `unless` nodes without
+  # other branches can be modifiers.
+  #
+  # @return [Boolean] whether the `if` node is a modifier
+  def modifier_form?; end
+
+  # Chacks whether the `if` node has nested `if` nodes in any of its
+  # branches.
+  #
+  # @note This performs a shallow search.
+  # @return [Boolean] whether the `if` node contains nested conditionals
+  def nested_conditional?; end
+
+  # Custom destructuring method. This is used to normalize the branches
+  # for `if` and `unless` nodes, to aid comparisons and conversions.
+  #
+  # @return [Array<Node>] the different parts of the `if` statement
+  def node_parts; end
+
+  # Checks whether the `if` node is a ternary operator.
+  #
+  # @return [Boolean] whether the `if` node is a ternary operator
+  def ternary?; end
+
+  # Checks whether this node is an `unless` statement. (This is not true
+  # of ternary operators and `if` statements.)
+  #
+  # @return [Boolean] whether the node is an `unless` statement
+  def unless?; end
+end
+
+# A node extension for `in` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `in` nodes within RuboCop.
+class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node
+  # Returns the body of the `in` node.
+  #
+  # @return [Node, nil] the body of the `in` node
+  def body; end
+
+  # Returns the index of the `in` branch within the `case` statement.
+  #
+  # @return [Integer] the index of the `in` branch
+  def branch_index; end
+
+  # Returns a node of the pattern in the `in` branch.
+  #
+  # @return [Node] a pattern node
+  def pattern; end
+
+  # Checks whether the `in` node has a `then` keyword.
+  #
+  # @return [Boolean] whether the `in` node has a `then` keyword
+  def then?; end
+end
+
+# Used for modern support only!
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "foo[:bar]"
+#   (index
+#     (send nil :foo)
+#     (sym :bar))
+#   $ ruby-parse --legacy -e "foo[:bar]"
+#   (send
+#     (send nil :foo) :[]
+#     (sym :bar))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  def method_name; end
+
+  private
+
+  # An array containing the arguments of the dispatched method.
+  #
+  # @return [Array<Node>] the arguments of the dispatched method
+  def first_argument_index; end
+end
+
+# Used for modern support only!
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "foo[:bar] = :baz"
+#   (indexasgn
+#     (send nil :foo)
+#     (sym :bar)
+#     (sym :baz))
+#   $ ruby-parse --legacy -e "foo[:bar] = :baz"
+#   (send
+#     (send nil :foo) :[]=
+#     (sym :bar)
+#     (sym :baz))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  def method_name; end
+
+  private
+
+  # An array containing the arguments of the dispatched method.
+  #
+  # @return [Array<Node>] the arguments of the dispatched method
+  def first_argument_index; end
+end
+
+# A node extension for `int` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available to
+# all `int` nodes within RuboCop.
+class RuboCop::AST::IntNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+  include ::RuboCop::AST::NumericNode
+end
+
+# 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.
+class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::HashElementNode
+
+  # This is used for duck typing with `pair` nodes which also appear as
+  # `hash` elements.
+  #
+  # @return [false]
+  def colon?; end
+
+  # This is used for duck typing with `pair` nodes which also appear as
+  # `hash` elements.
+  #
+  # @return [false]
+  def hash_rocket?; end
+
+  # Custom destructuring method. This is used to normalize the branches
+  # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements.
+  #
+  # @return [Array<KeywordSplatNode>] the different parts of the `kwsplat`
+  def node_parts; end
+
+  # Returns the operator for the `kwsplat` as a string.
+  #
+  # @return [String] the double splat operator
+  def operator; end
+end
+
+RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)
+
+# Used for modern support only:
+# Not as thoroughly tested as legacy equivalent
+#
+#   $ ruby-parse -e "->(foo) { bar }"
+#   (block
+#     (lambda)
+#     (args
+#       (arg :foo))
+#     (send nil :bar))
+#   $ ruby-parse --legacy -e "->(foo) { bar }"
+#   (block
+#     (send nil :lambda)
+#     (args
+#       (arg :foo))
+#     (send nil :bar))
+#
+# The main RuboCop runs in legacy mode; this node is only used
+# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def assignment_method?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def attribute_accessor?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def lambda?; end
+
+  # For similarity with legacy mode
+  #
+  # @return [Boolean]
+  def lambda_literal?; end
+
+  # For similarity with legacy mode
+  def method_name; end
+
+  # For similarity with legacy mode
+  def receiver; end
+
+  private
+
+  # For similarity with legacy mode
+  def first_argument_index; end
+end
+
+# Common functionality for nodes that are a kind of method dispatch:
+# `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`,
+# and (modern only): `index`, `indexasgn`, `lambda`
+module RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # Checks whether the dispatched method is an access modifier.
+  #
+  # @return [Boolean] whether the dispatched method is an access modifier
+  def access_modifier?; end
+
+  def adjacent_def_modifier?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this node is an arithmetic operation
+  #
+  # @return [Boolean] whether the dispatched method is an arithmetic
+  #   operation
+  def arithmetic_operation?; end
+
+  # Checks whether the dispatched method is a setter method.
+  #
+  # @return [Boolean] whether the dispatched method is a setter
+  def assignment?; end
+
+  # Checks whether the dispatched method is a bare access modifier that
+  # affects all methods defined after the macro.
+  #
+  # @return [Boolean] whether the dispatched method is a bare
+  #   access modifier
+  def bare_access_modifier?; end
+
+  def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this is a binary operation.
+  #
+  # @example
+  #
+  #   foo + bar
+  # @return [Bookean] whether this method is a binary operation
+  def binary_operation?; end
+
+  # Whether this method dispatch has an explicit block.
+  #
+  # @return [Boolean] whether the dispatched method has a block
+  def block_literal?; 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
+  #   call or `nil`
+  def block_node; end
+
+  # Checks whether the name of the dispatched method matches the argument
+  # and has an implicit receiver.
+  #
+  # @param name [Symbol, String] the method name to check for
+  # @return [Boolean] whether the method name matches the argument
+  def command?(name); end
+
+  # Checks whether the *explicit* receiver of this method dispatch is a
+  # `const` node.
+  #
+  # @return [Boolean] whether the receiver of this method dispatch
+  #   is a `const` node
+  def const_receiver?; end
+
+  # Checks if this node is part of a chain of `def` or `defs` modifiers.
+  #
+  # or `nil` if it isn't a def modifier
+  #
+  # @example
+  #
+  #   private def foo; end
+  # @return [Node | nil] returns the `def|defs` node this is a modifier for,
+  def def_modifier(node = T.unsafe(nil)); end
+
+  # Checks if this node is part of a chain of `def` or `defs` modifiers.
+  #
+  # See also `def_modifier` that returns the node or `nil`
+  #
+  # @example
+  #
+  #   private def foo; end
+  # @return [Boolean] whether the `def|defs` node is a modifier or not.
+  def def_modifier?(node = T.unsafe(nil)); end
+
+  # Checks whether the dispatched method uses a dot to connect the
+  # receiver and the method name.
+  #
+  # This is useful for comparison operators, which can be called either
+  # with or without a dot, i.e. `foo == bar` or `foo.== bar`.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  def dot?; end
+
+  # Checks whether the dispatched method uses a double colon to connect the
+  # receiver and the method name.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  def double_colon?; end
+
+  # Checks whether the method dispatch is the implicit form of `#call`,
+  # e.g. `foo.(bar)`.
+  #
+  # @return [Boolean] whether the method is the implicit form of `#call`
+  def implicit_call?; end
+
+  def in_macro_scope?(param0 = T.unsafe(nil)); end
+
+  # Checks whether this is a lambda. Some versions of parser parses
+  # non-literal lambdas as a method send.
+  #
+  # @return [Boolean] whether this method is a lambda
+  def lambda?; end
+
+  # Checks whether this is a lambda literal (stabby lambda.)
+  #
+  # @example
+  #
+  #   -> (foo) { bar }
+  # @return [Boolean] whether this method is a lambda literal
+  def lambda_literal?; end
+
+  # Checks whether the dispatched method is a macro method. A macro method
+  # is defined as a method that sits in a class, module, or block body and
+  # has an implicit receiver.
+  #
+  # @note This does not include DSLs that use nested blocks, like RSpec
+  # @return [Boolean] whether the dispatched method is a macro method
+  def macro?; end
+
+  # The name of the dispatched method as a symbol.
+  #
+  # @return [Symbol] the name of the dispatched method
+  def method_name; end
+
+  # Checks whether the dispatched method is a non-bare access modifier that
+  # affects only the method it receives.
+  #
+  # @return [Boolean] whether the dispatched method is a non-bare
+  #   access modifier
+  def non_bare_access_modifier?; end
+
+  def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end
+
+  # The receiving node of the method dispatch.
+  #
+  # @return [Node, nil] the receiver of the dispatched method or `nil`
+  def receiver; end
+
+  # Checks whether the dispatched method uses a safe navigation operator to
+  # connect the receiver and the method name.
+  #
+  # @return [Boolean] whether the method was called with a connecting dot
+  def safe_navigation?; end
+
+  # Checks whether the *explicit* receiver of this method dispatch is
+  # `self`.
+  #
+  # @return [Boolean] whether the receiver of this method dispatch is `self`
+  def self_receiver?; end
+
+  # Checks whether the dispatched method is a setter method.
+  #
+  # @return [Boolean] whether the dispatched method is a setter
+  def setter_method?; end
+
+  # Checks whether the dispatched method is a bare `private` or `protected`
+  # access modifier that affects all methods defined after the macro.
+  #
+  # @return [Boolean] whether the dispatched method is a bare
+  #   `private` or `protected` access modifier
+  def special_modifier?; end
+
+  # Checks whether this is a unary operation.
+  #
+  # @example
+  #
+  #   -foo
+  # @return [Boolean] whether this method is a unary operation
+  def unary_operation?; end
+end
+
+RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)
+RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)
+
+# Common predicates for nodes that reference method identifiers:
+# `send`, `csend`, `def`, `defs`, `super`, `zsuper`
+#
+# @note this mixin expects `#method_name` and `#receiver` to be implemented
+module RuboCop::AST::MethodIdentifierPredicates
+  # Checks whether the method is an assignment method.
+  #
+  # @return [Boolean] whether the method is an assignment
+  def assignment_method?; end
+
+  # Checks whether the method is a bang method.
+  #
+  # @return [Boolean] whether the method is a bang method
+  def bang_method?; end
+
+  # Checks whether the method is a camel case method,
+  # e.g. `Integer()`.
+  #
+  # @return [Boolean] whether the method is a camel case method
+  def camel_case_method?; end
+
+  # Checks whether the method is a comparison method.
+  #
+  # @return [Boolean] whether the method is a comparison
+  def comparison_method?; end
+
+  # Checks whether the *explicit* receiver of node is a `const` node.
+  #
+  # @return [Boolean] whether the receiver of this node is a `const` node
+  def const_receiver?; end
+
+  # Checks whether the method is an Enumerable method.
+  #
+  # @return [Boolean] whether the method is an Enumerable method
+  def enumerable_method?; end
+
+  # Checks whether the method is an enumerator method.
+  #
+  # @return [Boolean] whether the method is an enumerator
+  def enumerator_method?; end
+
+  # Checks whether the method name matches the argument.
+  #
+  # @param name [Symbol, String] the method name to check for
+  # @return [Boolean] whether the method name matches the argument
+  def method?(name); end
+
+  # Checks whether this is a negation method, i.e. `!` or keyword `not`.
+  #
+  # @return [Boolean] whether this method is a negation method
+  def negation_method?; end
+
+  # Checks whether the method is a nonmutating Array method.
+  #
+  # @return [Boolean] whether the method is a nonmutating Array method
+  def nonmutating_array_method?; end
+
+  # Checks whether the method is a nonmutating binary operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating binary operator method
+  def nonmutating_binary_operator_method?; end
+
+  # Checks whether the method is a nonmutating Hash method.
+  #
+  # @return [Boolean] whether the method is a nonmutating Hash method
+  def nonmutating_hash_method?; end
+
+  # Checks whether the method is a nonmutating operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating operator method
+  def nonmutating_operator_method?; end
+
+  # Checks whether the method is a nonmutating String method.
+  #
+  # @return [Boolean] whether the method is a nonmutating String method
+  def nonmutating_string_method?; end
+
+  # Checks whether the method is a nonmutating unary operator method.
+  #
+  # @return [Boolean] whether the method is a nonmutating unary operator method
+  def nonmutating_unary_operator_method?; end
+
+  # Checks whether the method is an operator method.
+  #
+  # @return [Boolean] whether the method is an operator
+  def operator_method?; end
+
+  # Checks whether the method is a predicate method.
+  #
+  # @return [Boolean] whether the method is a predicate method
+  def predicate_method?; end
+
+  # Checks whether this is a prefix bang method, e.g. `!foo`.
+  #
+  # @return [Boolean] whether this method is a prefix bang
+  def prefix_bang?; end
+
+  # Checks whether this is a prefix not method, e.g. `not foo`.
+  #
+  # @return [Boolean] whether this method is a prefix not
+  def prefix_not?; end
+
+  # Checks whether the *explicit* receiver of this node is `self`.
+  #
+  # @return [Boolean] whether the receiver of this node is `self`
+  def self_receiver?; end
+end
+
+RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# http://phrogz.net/programmingruby/language.html#table_18.4
+RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)
+
+# Common functionality for nodes that can be used as modifiers:
+# `if`, `while`, `until`
+module RuboCop::AST::ModifierNode
+  # Checks whether the node is in a modifier form, i.e. a condition
+  # trailing behind an expression.
+  #
+  # @return [Boolean] whether the node is a modifier
+  def modifier_form?; end
+end
+
+# A node extension for `module` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `module` nodes within RuboCop.
+class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
+  # The body of this `module` node.
+  #
+  # @return [Node, nil] the body of the module
+  def body; end
+
+  # The identifier for this `module` node.
+  #
+  # @return [Node] the identifier of the module
+  def identifier; end
+end
+
+# A node extension for `next` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `next` nodes within RuboCop.
+class RuboCop::AST::NextNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# `RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides
+# access to parent nodes and an object-oriented way to traverse an AST with
+# the power of `Enumerable`.
+#
+# It has predicate methods for every node type, like this:
+#
+# @example
+#   node.send_type?    # Equivalent to: `node.type == :send`
+#   node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`
+#
+#   # Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
+#   node.defined_type? # Equivalent to: `node.type == :defined?`
+#
+#   # Find the first lvar node under the receiver node.
+#   lvar_node = node.each_descendant.find(&:lvar_type?)
+class RuboCop::AST::Node < ::Parser::AST::Node
+  include ::RuboCop::AST::Sexp
+  include ::RuboCop::AST::Descendence
+  extend ::RuboCop::AST::NodePattern::Macros
+
+  # @return [Node] a new instance of Node
+  # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  def __ENCODING___type?; end
+  def __FILE___type?; end
+  def __LINE___type?; end
+  def alias_type?; end
+
+  # Returns an array of ancestor nodes.
+  # This is a shorthand for `node.each_ancestor.to_a`.
+  #
+  # @return [Array<Node>] an array of ancestor nodes
+  def ancestors; end
+
+  def and_asgn_type?; end
+  def and_type?; end
+  def arg_expr_type?; end
+  def arg_type?; end
+  def args_type?; end
+
+  # @return [Boolean]
+  def argument?; end
+
+  # @return [Boolean]
+  def argument_type?; end
+
+  def array_pattern_type?; end
+  def array_pattern_with_tail_type?; end
+  def array_type?; end
+
+  # @return [Boolean]
+  def assignment?; end
+
+  # Some cops treat the shovel operator as a kind of assignment.
+  def assignment_or_similar?(param0 = T.unsafe(nil)); end
+
+  def back_ref_type?; end
+
+  # @return [Boolean]
+  def basic_conditional?; end
+
+  # @return [Boolean]
+  def basic_literal?; end
+
+  def begin_type?; end
+  def block_pass_type?; end
+  def block_type?; end
+  def blockarg_expr_type?; end
+  def blockarg_type?; end
+
+  # @return [Boolean]
+  def boolean_type?; end
+
+  def break_type?; end
+
+  # @return [Boolean]
+  def call_type?; end
+
+  def case_match_type?; end
+  def case_type?; end
+  def casgn_type?; end
+  def cbase_type?; end
+
+  # @return [Boolean]
+  def chained?; end
+
+  def class_constructor?(param0 = T.unsafe(nil)); end
+  def class_definition?(param0 = T.unsafe(nil)); end
+  def class_type?; end
+  def complete!; end
+
+  # @return [Boolean]
+  def complete?; end
+
+  def complex_type?; end
+
+  # @return [Boolean]
+  def conditional?; end
+
+  def const_name; end
+  def const_pattern_type?; end
+  def const_type?; end
+  def csend_type?; end
+  def cvar_type?; end
+  def cvasgn_type?; end
+  def def_type?; end
+  def defined_module; end
+  def defined_module_name; end
+  def defined_type?; end
+  def defs_type?; end
+  def dstr_type?; end
+  def dsym_type?; end
+
+  # Calls the given block for each ancestor node from parent to root.
+  # If no block is given, an `Enumerator` is returned.
+  #
+  # @overload each_ancestor
+  # @overload each_ancestor
+  # @overload each_ancestor
+  # @return [self] if a block is given
+  # @return [Enumerator] if no block is given
+  # @yieldparam node [Node] each ancestor node
+  def each_ancestor(*types, &block); end
+
+  def eflipflop_type?; end
+  def empty_else_type?; end
+
+  # @return [Boolean]
+  def empty_source?; end
+
+  def ensure_type?; end
+
+  # @return [Boolean]
+  def equals_asgn?; end
+
+  def erange_type?; end
+  def false_type?; end
+
+  # @return [Boolean]
+  def falsey_literal?; end
+
+  def find_pattern_type?; end
+  def first_line; end
+  def float_type?; end
+  def for_type?; end
+  def forward_arg_type?; end
+  def forward_args_type?; end
+  def forwarded_args_type?; end
+  def global_const?(param0 = T.unsafe(nil), param1); end
+
+  # @return [Boolean]
+  def guard_clause?; end
+
+  def gvar_type?; end
+  def gvasgn_type?; end
+  def hash_pattern_type?; end
+  def hash_type?; end
+  def ident_type?; end
+  def if_guard_type?; end
+  def if_type?; end
+  def iflipflop_type?; end
+
+  # @return [Boolean]
+  def immutable_literal?; end
+
+  def in_match_type?; end
+  def in_pattern_type?; end
+  def index_type?; end
+  def indexasgn_type?; end
+  def int_type?; end
+  def irange_type?; end
+  def ivar_type?; end
+  def ivasgn_type?; end
+
+  # @return [Boolean]
+  def keyword?; end
+
+  def kwarg_type?; end
+  def kwargs_type?; end
+  def kwbegin_type?; end
+  def kwnilarg_type?; end
+  def kwoptarg_type?; end
+  def kwrestarg_type?; end
+  def kwsplat_type?; end
+  def lambda?(param0 = T.unsafe(nil)); end
+  def lambda_or_proc?(param0 = T.unsafe(nil)); end
+  def lambda_type?; end
+  def last_line; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Node, nil] the left (aka previous) sibling
+  def left_sibling; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Array<Node>] the left (aka previous) siblings
+  def left_siblings; end
+
+  def line_count; end
+
+  # @return [Boolean]
+  def literal?; end
+
+  # NOTE: `loop { }` is a normal method call and thus not a loop keyword.
+  #
+  # @return [Boolean]
+  def loop_keyword?; end
+
+  def lvar_type?; end
+  def lvasgn_type?; end
+  def masgn_type?; end
+  def match_alt_type?; end
+  def match_as_type?; end
+  def match_current_line_type?; end
+  def match_guard_clause?(param0 = T.unsafe(nil)); end
+  def match_nil_pattern_type?; end
+  def match_pattern_p_type?; end
+  def match_pattern_type?; end
+  def match_rest_type?; end
+  def match_var_type?; end
+  def match_with_lvasgn_type?; end
+  def match_with_trailing_comma_type?; end
+  def mlhs_type?; end
+  def module_definition?(param0 = T.unsafe(nil)); end
+  def module_type?; end
+
+  # Predicates
+  #
+  # @return [Boolean]
+  def multiline?; end
+
+  # @return [Boolean]
+  def mutable_literal?; end
+
+  def new_class_or_module_block?(param0 = T.unsafe(nil)); end
+  def next_type?; end
+  def nil_type?; end
+
+  # Common destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  # Some node types override this with their own custom
+  # destructuring method.
+  #
+  # @return [Array<Node>] the different parts of the ndde
+  def node_parts; end
+
+  def nonempty_line_count; end
+  def not_type?; end
+  def nth_ref_type?; end
+  def numargs_type?; end
+  def numblock_type?; end
+
+  # @return [Boolean]
+  def numeric_type?; end
+
+  def objc_kwarg_type?; end
+  def objc_restarg_type?; end
+  def objc_varargs_type?; end
+  def op_asgn_type?; end
+
+  # @return [Boolean]
+  def operator_keyword?; end
+
+  def optarg_type?; end
+  def or_asgn_type?; end
+  def or_type?; end
+  def pair_type?; end
+
+  # Returns the parent node, or `nil` if the receiver is a root node.
+  #
+  # @return [Node, nil] the parent node or `nil`
+  def parent; end
+
+  # @return [Boolean]
+  def parent?; end
+
+  # Searching the AST
+  def parent_module_name; end
+
+  # @return [Boolean]
+  def parenthesized_call?; end
+
+  def pin_type?; end
+
+  # @return [Boolean]
+  def post_condition_loop?; end
+
+  def postexe_type?; end
+  def preexe_type?; end
+  def proc?(param0 = T.unsafe(nil)); end
+  def procarg0_type?; end
+
+  # Some expressions are evaluated for their value, some for their side
+  # effects, and some for both.
+  # If we know that expressions are useful only for their return values,
+  # and have no side effects, that means we can reorder them, change the
+  # number of times they are evaluated, or replace them with other
+  # expressions which are equivalent in value.
+  # So, is evaluation of this node free of side effects?
+  #
+  # @return [Boolean]
+  def pure?; end
+
+  # @return [Boolean]
+  def range_type?; end
+
+  def rational_type?; end
+  def receiver(param0 = T.unsafe(nil)); end
+  def recursive_basic_literal?; end
+  def recursive_literal?; end
+  def redo_type?; end
+
+  # @return [Boolean]
+  def reference?; end
+
+  def regexp_type?; end
+  def regopt_type?; end
+  def resbody_type?; end
+  def rescue_type?; end
+  def restarg_expr_type?; end
+  def restarg_type?; end
+  def retry_type?; end
+  def return_type?; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Node, nil] the right (aka next) sibling
+  def right_sibling; end
+
+  # Use is discouraged, this is a potentially slow method and can lead
+  # to even slower algorithms
+  #
+  # @return [Array<Node>] the right (aka next) siblings
+  def right_siblings; end
+
+  # @return [Boolean]
+  def root?; end
+
+  def sclass_type?; end
+  def self_type?; end
+  def send_type?; end
+  def shadowarg_type?; end
+
+  # @return [Boolean]
+  def shorthand_asgn?; end
+
+  # Returns the index of the receiver node in its siblings. (Sibling index
+  # uses zero based numbering.)
+  # Use is discouraged, this is a potentially slow method.
+  #
+  # @return [Integer, nil] the index of the receiver node in its siblings
+  def sibling_index; end
+
+  # @return [Boolean]
+  def single_line?; end
+
+  # NOTE: Some rare nodes may have no source, like `s(:args)` in `foo {}`
+  #
+  # @return [String, nil]
+  def source; end
+
+  def source_length; end
+  def source_range; end
+
+  # @return [Boolean]
+  def special_keyword?; end
+
+  def splat_type?; end
+  def str_content(param0 = T.unsafe(nil)); end
+  def str_type?; end
+
+  # @deprecated Use `:class_constructor?`
+  def struct_constructor?(param0 = T.unsafe(nil)); end
+
+  def super_type?; end
+  def sym_type?; end
+  def true_type?; end
+
+  # @return [Boolean]
+  def truthy_literal?; end
+
+  def undef_type?; end
+  def unless_guard_type?; end
+  def until_post_type?; end
+  def until_type?; end
+
+  # Override `AST::Node#updated` so that `AST::Processor` does not try to
+  # mutate our ASTs. Since we keep references from children to parents and
+  # not just the other way around, we cannot update an AST and share
+  # identical subtrees. Rather, the entire AST must be copied any time any
+  # part of it is changed.
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  # Some expressions are evaluated for their value, some for their side
+  # effects, and some for both
+  # If we know that an expression is useful only for its side effects, that
+  # means we can transform it in ways which preserve the side effects, but
+  # change the return value
+  # So, does the return value of this node matter? If we changed it to
+  # `(...; nil)`, might that affect anything?
+  #
+  #
+  # @return [Boolean]
+  def value_used?; end
+
+  # @return [Boolean]
+  def variable?; end
+
+  def when_type?; end
+  def while_post_type?; end
+  def while_type?; end
+  def xstr_type?; end
+  def yield_type?; end
+  def zsuper_type?; end
+
+  protected
+
+  def parent=(node); end
+
+  private
+
+  # @return [Boolean]
+  def begin_value_used?; end
+
+  # @return [Boolean]
+  def case_if_value_used?; end
+
+  def defined_module0(param0 = T.unsafe(nil)); end
+
+  # @return [Boolean]
+  def for_value_used?; end
+
+  def parent_module_name_for_block(ancestor); end
+  def parent_module_name_for_sclass(sclass_node); end
+  def parent_module_name_part(node); end
+  def visit_ancestors(types); end
+
+  # @return [Boolean]
+  def while_until_value_used?; end
+end
+
+# @api private
+RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set)
+
+# <=> isn't included here, because it doesn't return a boolean.
+#
+# @api private
+RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set)
+
+RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set)
+
+# @api private
+RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set)
+
+# This class performs a pattern-matching operation on an AST node.
+#
+# Detailed syntax: /docs/modules/ROOT/pages/node_pattern.adoc
+#
+# Initialize a new `NodePattern` with `NodePattern.new(pattern_string)`, then
+# pass an AST node to `NodePattern#match`. Alternatively, use one of the class
+# macros in `NodePattern::Macros` to define your own pattern-matching method.
+#
+# If the match fails, `nil` will be returned. If the match succeeds, the
+# return value depends on whether a block was provided to `#match`, and
+# whether the pattern contained any "captures" (values which are extracted
+# from a matching AST.)
+#
+# - With block: #match yields the captures (if any) and passes the return
+#               value of the block through.
+# - With no block, but one capture: the capture is returned.
+# - With no block, but multiple captures: captures are returned as an array.
+# - With no block and no captures: #match returns `true`.
+class RuboCop::AST::NodePattern
+  include ::RuboCop::AST::NodePattern::MethodDefiner
+  extend ::Forwardable
+
+  # @return [NodePattern] a new instance of NodePattern
+  def initialize(str, compiler: T.unsafe(nil)); end
+
+  def ==(other); end
+  def as_json(_options = T.unsafe(nil)); end
+
+  # Returns the value of attribute ast.
+  def ast; end
+
+  def captures(*args, &block); end
+  def encode_with(coder); end
+  def eql?(other); end
+  def freeze; end
+  def init_with(coder); end
+  def marshal_dump; end
+  def marshal_load(pattern); end
+  def match(*args, **rest, &block); end
+
+  # Returns the value of attribute match_code.
+  def match_code; end
+
+  def named_parameters(*args, &block); end
+
+  # Returns the value of attribute pattern.
+  def pattern; end
+
+  def positional_parameters(*args, &block); end
+  def to_s; end
+
+  class << self
+    # Yields its argument and any descendants, depth-first.
+    #
+    # @yield [element]
+    def descend(element, &block); end
+  end
+end
+
+# Responsible to build the AST nodes for `NodePattern`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Builder
+  def emit_atom(type, value); end
+  def emit_call(type, selector, args = T.unsafe(nil)); end
+  def emit_capture(capture_token, node); end
+  def emit_list(type, _begin, children, _end); end
+  def emit_subsequence(node_list); end
+  def emit_unary_op(type, _operator = T.unsafe(nil), *children); end
+  def emit_union(begin_t, pattern_lists, end_t); end
+
+  private
+
+  def n(type, *args); end
+
+  # @return [Boolean]
+  def optimizable_as_set?(children); end
+
+  def union_children(pattern_lists); end
+end
+
+# A NodePattern comment, simplified version of ::Parser::Source::Comment
+class RuboCop::AST::NodePattern::Comment
+  # @param range [Parser::Source::Range]
+  # @return [Comment] a new instance of Comment
+  def initialize(range); end
+
+  # Compares comments. Two comments are equal if they
+  # correspond to the same source range.
+  #
+  # @param other [Object]
+  # @return [Boolean]
+  def ==(other); end
+
+  # @return [String] a human-readable representation of this comment
+  def inspect; end
+
+  # Returns the value of attribute location.
+  def loc; end
+
+  # Returns the value of attribute location.
+  def location; end
+
+  # @return [String]
+  def text; end
+end
+
+# The top-level compiler holding the global state
+# Defers work to its subcompilers
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Compiler
+  extend ::Forwardable
+
+  # @return [Compiler] a new instance of Compiler
+  def initialize; end
+
+  def bind(*args, &block); end
+
+  # Returns the value of attribute binding.
+  def binding; end
+
+  # Returns the value of attribute captures.
+  def captures; end
+
+  def compile_as_atom(node); end
+  def compile_as_node_pattern(node, **options); end
+  def compile_sequence(sequence, var:); end
+
+  # Enumerates `enum` while keeping track of state across
+  # union branches (captures and unification).
+  def each_union(enum, &block); end
+
+  def freeze; end
+  def named_parameter(name); end
+
+  # Returns the value of attribute named_parameters.
+  def named_parameters; end
+
+  def next_capture; end
+  def parser; end
+  def positional_parameter(number); end
+
+  # Returns the value of attribute positional_parameters.
+  def positional_parameters; end
+
+  # Utilities
+  def with_temp_variables(*names, &block); end
+
+  private
+
+  def enforce_same_captures(enum); end
+  def new_capture; end
+end
+
+# Generates code that evaluates to a value (Ruby object)
+# This value responds to `===`.
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  private
+
+  def visit_const; end
+  def visit_named_parameter; end
+  def visit_number; end
+
+  # Assumes other types are node patterns.
+  def visit_other_type; end
+
+  def visit_positional_parameter; end
+  def visit_regexp; end
+  def visit_set; end
+  def visit_string; end
+  def visit_symbol; end
+  def visit_unify; end
+end
+
+# Holds the list of bound variable names
+class RuboCop::AST::NodePattern::Compiler::Binding
+  # @return [Binding] a new instance of Binding
+  def initialize; end
+
+  # Yields the first time a given name is bound
+  #
+  # @return [String] bound variable name
+  def bind(name); end
+
+  def union_bind(enum); end
+
+  private
+
+  def forbid(names); end
+end
+
+# Variant of the Compiler with tracing information for nodes
+class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler
+  # @return [Debug] a new instance of Debug
+  def initialize; end
+
+  def comments(*args, &block); end
+  def named_parameters; end
+
+  # Returns the value of attribute node_ids.
+  def node_ids; end
+
+  def parser; end
+  def tokens(*args, &block); end
+end
+
+# @api private
+class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer
+  # @api private
+  # @return [Colorizer] a new instance of Colorizer
+  def initialize(pattern, compiler: T.unsafe(nil)); end
+
+  # @api private
+  def compiler; end
+
+  # @api private
+  def node_pattern; end
+
+  # @api private
+  def pattern; end
+
+  # @api private
+  # @return [Node] the Ruby AST
+  def test(ruby, trace: T.unsafe(nil)); end
+
+  private
+
+  # @api private
+  def ruby_ast(ruby); end
+
+  # @api private
+  def ruby_parser; end
+end
+
+# @api private
+RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash)
+
+# @api private
+RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug
+
+# Result of a NodePattern run against a particular AST
+# Consider constructor is private
+#
+# @api private
+class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct
+  # @api private
+  # @return [Hash] a map for {character_position => color}
+  def color_map(color_scheme = T.unsafe(nil)); end
+
+  # @api private
+  # @return [String] a Rainbow colorized version of ruby
+  def colorize(color_scheme = T.unsafe(nil)); end
+
+  # Returns the value of attribute colorizer
+  #
+  # @return [Object] the current value of colorizer
+  def colorizer; end
+
+  # Sets the attribute colorizer
+  #
+  # @param value [Object] the value to set the attribute colorizer to.
+  # @return [Object] the newly set value
+  def colorizer=(_); end
+
+  # @api private
+  # @return [Hash] a map for {node => matched?}, depth-first
+  def match_map; end
+
+  # @api private
+  # @return [Boolean] a value of `Trace#matched?` or `:not_visitable`
+  def matched?(node); end
+
+  # Returns the value of attribute returned
+  #
+  # @return [Object] the current value of returned
+  def returned; end
+
+  # Sets the attribute returned
+  #
+  # @param value [Object] the value to set the attribute returned to.
+  # @return [Object] the newly set value
+  def returned=(_); end
+
+  # Returns the value of attribute ruby_ast
+  #
+  # @return [Object] the current value of ruby_ast
+  def ruby_ast; end
+
+  # Sets the attribute ruby_ast
+  #
+  # @param value [Object] the value to set the attribute ruby_ast to.
+  # @return [Object] the newly set value
+  def ruby_ast=(_); end
+
+  # Returns the value of attribute trace
+  #
+  # @return [Object] the current value of trace
+  def trace; end
+
+  # Sets the attribute trace
+  #
+  # @param value [Object] the value to set the attribute trace to.
+  # @return [Object] the newly set value
+  def trace=(_); end
+
+  private
+
+  # @api private
+  def ast; end
+
+  # @api private
+  def color_map_for(node, color); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# @api private
+module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+  # @api private
+  def do_compile; end
+
+  private
+
+  # @api private
+  def node_id; end
+
+  # @api private
+  def tracer(kind); end
+end
+
+# @api private
+class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler
+  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+end
+
+# @api private
+class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler
+  include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler
+end
+
+# Compiled node pattern requires a named parameter `trace`,
+# which should be an instance of this class
+class RuboCop::AST::NodePattern::Compiler::Debug::Trace
+  # @return [Trace] a new instance of Trace
+  def initialize; end
+
+  def enter(node_id); end
+
+  # return nil (not visited), false (not matched) or true (matched)
+  #
+  # @return [Boolean]
+  def matched?(node_id); end
+
+  def success(node_id); end
+end
+
+# Compiles code that evalues to true or false
+# for a given value `var` (typically a RuboCop::AST::Node)
+# or it's `node.type` if `seq_head` is true
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # @return [NodePatternSubcompiler] a new instance of NodePatternSubcompiler
+  def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end
+
+  # Returns the value of attribute access.
+  def access; end
+
+  # Returns the value of attribute seq_head.
+  def seq_head; end
+
+  private
+
+  def access_element; end
+  def access_node; end
+
+  # @param [Array<Node>, nil]
+  # @return [String, nil]
+  def compile_args(arg_list, first: T.unsafe(nil)); end
+
+  def compile_guard_clause; end
+
+  # Compiling helpers
+  def compile_value_match(value); end
+
+  def multiple_access(kind); end
+  def visit_ascend; end
+  def visit_capture; end
+  def visit_descend; end
+  def visit_function_call; end
+  def visit_intersection; end
+  def visit_negation; end
+  def visit_node_type; end
+
+  # Assumes other types are atoms.
+  def visit_other_type; end
+
+  def visit_predicate; end
+  def visit_sequence; end
+  def visit_unify; end
+
+  # Lists
+  def visit_union; end
+
+  def visit_wildcard; end
+end
+
+# Compiles terms within a sequence to code that evalues to true or false.
+# Compilation of the nodes that can match only a single term is deferred to
+# `NodePatternSubcompiler`; only nodes that can match multiple terms are
+# compiled here.
+# Assumes the given `var` is a `::RuboCop::AST::Node`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+#
+class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # Calls `compile_sequence`; the actual `compile` method
+  # will be used for the different terms of the sequence.
+  # The only case of re-entrant call to `compile` is `visit_capture`
+  #
+  # @return [SequenceSubcompiler] a new instance of SequenceSubcompiler
+  def initialize(compiler, sequence:, var:); end
+
+  def compile_sequence; end
+
+  # @api private
+  def in_sync; end
+
+  protected
+
+  def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end
+
+  # @api private
+  def cur_index; end
+
+  # yield `sync_code` iff not already in sync
+  #
+  # @yield [code]
+  def sync; end
+
+  private
+
+  # Compilation helpers
+  def compile_and_advance(term); end
+
+  def compile_any_order_branches(matched_var); end
+
+  # @return [Array<String>] Else code, and init code (if any)
+  def compile_any_order_else; end
+
+  def compile_captured_repetition(child_code, child_captures); end
+  def compile_case(when_branches, else_code); end
+  def compile_child_nb_guard(arity_range); end
+  def compile_cur_index; end
+  def compile_index(cur = T.unsafe(nil)); end
+  def compile_loop(term); end
+  def compile_loop_advance(to = T.unsafe(nil)); end
+
+  # Assumes `@cur_index` is already updated
+  def compile_matched(kind); end
+
+  def compile_max_matched; end
+
+  # @return [String] code that evaluates to `false` if the matched arity is too small
+  def compile_min_check; end
+
+  def compile_remaining; end
+
+  # @return [Hash] of {subcompiler => code}
+  def compile_union_forks; end
+
+  def empty_loop; end
+  def handle_prev; end
+
+  # Modifies in place `forks`
+  # Syncs our state
+  def merge_forks!(forks); end
+
+  # Modifies in place `forks` to insure that `cur_{child|index}_var` are ok
+  def preserve_union_start(forks); end
+
+  # E.g. For sequence `(_  _? <_ _>)`, arities are: 1, 0..1, 2
+  # and remaining arities are: 3..4, 2..3, 2..2, 0..0
+  #
+  # @return [Array<Range>] total arities (as Ranges) of remaining children nodes
+  def remaining_arities(children, last_arity); end
+
+  # returns truthy iff `@cur_index` switched to relative from end mode (i.e. < 0)
+  def use_index_from_end; end
+
+  def visit_any_order; end
+  def visit_capture; end
+
+  # Single node patterns are all handled here
+  def visit_other_type; end
+
+  def visit_repetition; end
+  def visit_rest; end
+  def visit_union; end
+
+  # NOTE: assumes `@cur_index != :seq_head`. Node types using `within_loop` must
+  # have `def in_sequence_head; :raise; end`
+  def within_loop; end
+end
+
+RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer)
+RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc)
+
+# Base class for subcompilers
+# Implements visitor pattern
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Compiler::Subcompiler
+  # @return [Subcompiler] a new instance of Subcompiler
+  def initialize(compiler); end
+
+  def compile(node); end
+
+  # Returns the value of attribute compiler.
+  def compiler; end
+
+  private
+
+  def do_compile; end
+
+  # Returns the value of attribute node.
+  def node; end
+
+  class << self
+    # @private
+    def inherited(base); end
+
+    # @private
+    def method_added(method); end
+
+    # Returns the value of attribute registry.
+    def registry; end
+  end
+end
+
+class RuboCop::AST::NodePattern::Invalid < ::StandardError; end
+
+# Lexer class for `NodePattern`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex
+  # @return [Lexer] a new instance of Lexer
+  def initialize(source); end
+
+  # Returns the value of attribute comments.
+  def comments; end
+
+  # Returns the value of attribute source_buffer.
+  def source_buffer; end
+
+  # Returns the value of attribute tokens.
+  def tokens; end
+
+  private
+
+  def do_parse; end
+
+  # @return [token]
+  def emit(type); end
+
+  def emit_comment; end
+  def emit_regexp; end
+  def token(type, value); end
+end
+
+RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError
+RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The generated lexer RuboCop::AST::NodePattern::LexerRex
+class RuboCop::AST::NodePattern::LexerRex
+  # Yields on the current action.
+  def action; end
+
+  # The file name / path
+  def filename; end
+
+  # The file name / path
+  def filename=(_arg0); end
+
+  # The current location in the parse.
+  def location; end
+
+  # The StringScanner for this lexer.
+  def match; end
+
+  # The match groups for the current scan.
+  def matches; end
+
+  # Lex the next token.
+  def next_token; end
+
+  # Parse the given string.
+  def parse(str); end
+
+  # Read in and parse the file at +path+.
+  def parse_file(path); end
+
+  # The current scanner class. Must be overridden in subclasses.
+  def scanner_class; end
+
+  # The StringScanner for this lexer.
+  def ss; end
+
+  # The StringScanner for this lexer.
+  def ss=(_arg0); end
+
+  # The current lexical state.
+  def state; end
+
+  # The current lexical state.
+  def state=(_arg0); end
+end
+
+RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp)
+
+# :stopdoc:
+RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+
+# :startdoc:
+# :stopdoc:
+class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end
+
+RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp)
+RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp)
+RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp)
+RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp)
+class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end
+
+# Helpers for defining methods based on a pattern string
+module RuboCop::AST::NodePattern::Macros
+  # Define a method which applies a pattern to an AST node
+  #
+  # The new method will return nil if the node does not match.
+  # If the node matches, and a block is provided, the new method will
+  # yield to the block (passing any captures as block arguments).
+  # If the node matches, and no block is provided, the new method will
+  # return the captures, or `true` if there were none.
+  def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
+
+  # Define a method which recurses over the descendants of an AST node,
+  # checking whether any of them match the provided pattern
+  #
+  # If the method name ends with '?', the new method will return `true`
+  # as soon as it finds a descendant which matches. Otherwise, it will
+  # yield all descendants which match.
+  def def_node_search(method_name, pattern_str, **keyword_defaults); end
+end
+
+# Functionality to turn `match_code` into methods/lambda
+module RuboCop::AST::NodePattern::MethodDefiner
+  def as_lambda; end
+  def compile_as_lambda; end
+  def def_node_matcher(base, method_name, **defaults); end
+  def def_node_search(base, method_name, **defaults); end
+
+  private
+
+  def compile_init; end
+  def def_helper(base, method_name, **defaults); end
+  def emit_keyword_list(forwarding: T.unsafe(nil)); end
+  def emit_lambda_code; end
+  def emit_method_code; end
+  def emit_node_search(method_name); end
+  def emit_node_search_body(method_name, prelude:, on_match:); end
+  def emit_param_list; end
+  def emit_params(*first, forwarding: T.unsafe(nil)); end
+  def emit_retval; end
+  def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end
+
+  # This method minimizes the closure for our method
+  def wrapping_block(method_name, **defaults); end
+end
+
+# Base class for AST Nodes of a `NodePattern`
+class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node
+  include ::RuboCop::AST::Descendence
+  extend ::Forwardable
+
+  # Note: `arity.end` may be `Float::INFINITY`
+  #
+  # @return [Integer, Range] An Integer for fixed length terms, otherwise a Range.
+  def arity; end
+
+  # @return [Range] arity as a Range
+  def arity_range; end
+
+  # @return [Boolean]
+  def capture?; end
+
+  # @return [Node] most nodes have only one child
+  def child; end
+
+  # @return [Array<Node>]
+  def children_nodes; end
+
+  # @return [Array<Node>, nil] replace node with result, or `nil` if no change requested.
+  def in_sequence_head; end
+
+  # that matches within a Set (e.g. `42`, `:sym` but not `/regexp/`)
+  #
+  # @return [Boolean] returns true for nodes having a Ruby literal equivalent
+  def matches_within_set?; end
+
+  # @return [Integer] nb of captures of that node and its descendants
+  def nb_captures; end
+
+  # To be overridden by subclasses
+  #
+  # @return [Boolean]
+  def rest?; end
+
+  # @return [Boolean] returns whether it matches a variable number of elements
+  def variadic?; end
+
+  def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end
+end
+
+# Node class for `<int str ...>`
+class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  def arity; end
+
+  # @return [Boolean]
+  def ends_with_rest?; end
+
+  def rest_node; end
+  def term_nodes; end
+end
+
+RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash)
+
+# Node class for `$something`
+class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node
+  def arity(*args, &block); end
+
+  # @return [Boolean]
+  def capture?; end
+
+  def in_sequence_head; end
+  def nb_captures; end
+  def rest?(*args, &block); end
+end
+
+module RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+  # @raise [NodePattern::Invalid]
+  def in_sequence_head; end
+end
+
+RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate
+RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash)
+
+# Registry
+RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash)
+
+RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set)
+
+# Node class for `predicate?(:arg, :list)`
+class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node
+  def arg_list; end
+  def method_name; end
+end
+
+# Node class for `int+`
+class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  def arity; end
+  def operator; end
+end
+
+RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash)
+
+# Node class for `...`
+class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node
+  def arity; end
+  def in_sequence_head; end
+
+  # @return [Boolean]
+  def rest?; end
+end
+
+RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range)
+
+# Node class for `(type first second ...)`
+class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  # @return [Sequence] a new instance of Sequence
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+end
+
+# A list (potentially empty) of nodes; part of a Union
+class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node
+  include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead
+
+  def arity; end
+  def in_sequence_head; end
+end
+
+# Node class for `{ ... }`
+class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node
+  def arity; end
+  def in_sequence_head; end
+end
+
+# Parser for NodePattern
+# Note: class reopened in `parser.racc`
+#
+# Doc on how this fits in the compiling process:
+#   /docs/modules/ROOT/pages/node_pattern.adoc
+class RuboCop::AST::NodePattern::Parser < ::Racc::Parser
+  extend ::Forwardable
+
+  # @return [Parser] a new instance of Parser
+  def initialize(builder = T.unsafe(nil)); end
+
+  def _reduce_10(val, _values); end
+  def _reduce_11(val, _values); end
+
+  # reduce 12 omitted
+  def _reduce_13(val, _values); end
+
+  def _reduce_14(val, _values); end
+  def _reduce_15(val, _values); end
+  def _reduce_16(val, _values); end
+  def _reduce_17(val, _values); end
+  def _reduce_18(val, _values); end
+  def _reduce_19(val, _values); end
+
+  # reduce 1 omitted
+  def _reduce_2(val, _values); end
+
+  def _reduce_20(val, _values); end
+  def _reduce_21(val, _values); end
+  def _reduce_22(val, _values); end
+
+  # reduce 24 omitted
+  def _reduce_25(val, _values); end
+
+  def _reduce_26(val, _values); end
+  def _reduce_3(val, _values); end
+
+  # reduce 32 omitted
+  def _reduce_33(val, _values); end
+
+  # reduce 36 omitted
+  def _reduce_37(val, _values); end
+
+  def _reduce_38(val, _values); end
+  def _reduce_39(val, _values); end
+  def _reduce_4(val, _values); end
+  def _reduce_40(val, _values); end
+  def _reduce_41(val, _values); end
+  def _reduce_42(val, _values); end
+  def _reduce_43(val, _values); end
+  def _reduce_44(val, _values); end
+  def _reduce_45(val, _values); end
+  def _reduce_46(val, _values); end
+  def _reduce_5(val, _values); end
+  def _reduce_6(val, _values); end
+  def _reduce_7(val, _values); end
+  def _reduce_8(val, _values); end
+  def _reduce_9(val, _values); end
+  def _reduce_none(val, _values); end
+  def emit_atom(*args, &block); end
+  def emit_call(*args, &block); end
+  def emit_capture(*args, &block); end
+  def emit_list(*args, &block); end
+  def emit_unary_op(*args, &block); end
+  def emit_union(*args, &block); end
+  def inspect; end
+  def next_token(*args, &block); end
+
+  # (Similar API to `parser` gem)
+  # Parses a source and returns the AST.
+  #
+  # @param source_buffer [Parser::Source::Buffer, String] The source buffer to parse.
+  # @return [NodePattern::Node]
+  def parse(source); end
+
+  private
+
+  # @raise [NodePattern::Invalid]
+  def enforce_unary(node); end
+
+  # Overrides Racc::Parser's method:
+  #
+  # @raise [NodePattern::Invalid]
+  def on_error(token, val, _vstack); end
+end
+
+RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder
+RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer
+RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
+RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
+# Overrides Parser to use `WithMeta` variants and provide additional methods
+class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser
+  # Returns the value of attribute comments.
+  def comments; end
+
+  def do_parse; end
+
+  # Returns the value of attribute tokens.
+  def tokens; end
+end
+
+# Overrides Builder to emit nodes with locations
+class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder
+  def emit_atom(type, token); end
+  def emit_call(type, selector_t, args = T.unsafe(nil)); end
+  def emit_list(type, begin_t, children, end_t); end
+  def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end
+
+  private
+
+  def join_exprs(left_expr, right_expr); end
+  def loc(token_or_range); end
+  def n(type, children, source_map); end
+  def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end
+end
+
+# Overrides Lexer to token locations and comments
+class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer
+  # @return [Lexer] a new instance of Lexer
+  def initialize(str_or_buffer); end
+
+  def emit_comment; end
+
+  # @return [::Parser::Source::Range] last match's position
+  def pos; end
+
+  # Returns the value of attribute source_buffer.
+  def source_buffer; end
+
+  def token(type, value); end
+end
+
+# Utility to assign a set of values to a constant
+module RuboCop::AST::NodePattern::Sets
+  class << self
+    def [](set); end
+    def name(set); end
+    def uniq(name); end
+  end
+end
+
+RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer)
+RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash)
+RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_EXIST_EXISTS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_FILETEST_FILE_DIR_SHELL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C_TO_R = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_TYPE_TEMPLATE_TYPE_MEMBER = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET__FETCH = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___EQL_ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___EQL_INCLUDE = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set)
+RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String)
+
+# Common functionality for primitive numeric nodes: `int`, `float`, ...
+module RuboCop::AST::NumericNode
+  # Checks whether this is literal has a sign.
+  #
+  # @example
+  #
+  #   +42
+  # @return [Boolean] whether this literal has a sign.
+  def sign?; end
+end
+
+RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node
+  # @return [AsgnNode] the assignment node
+  def assignment_node; end
+
+  # The expression being assigned to the variable.
+  #
+  # @return [Node] the expression being assigned.
+  def expression; end
+
+  # The name of the variable being assigned as a symbol.
+  #
+  # @return [Symbol] the name of the variable being assigned
+  def name; end
+
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  def operator; end
+end
+
+# A node extension for `op_asgn` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all assignment nodes within RuboCop.
+class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode
+  # The operator being used for assignment as a symbol.
+  #
+  # @return [Symbol] the assignment operator
+  def operator; end
+end
+
+# A node extension for `or` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `or` nodes within RuboCop.
+class RuboCop::AST::OrNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+
+  # Returns the alternate operator of the `or` as a string.
+  # Returns `or` for `||` and vice versa.
+  #
+  # @return [String] the alternate of the `or` operator
+  def alternate_operator; end
+
+  # Returns the inverse keyword of the `or` node as a string.
+  # Returns `and` for `or` and `&&` for `||`.
+  #
+  # @return [String] the inverse of the `or` operator
+  def inverse_operator; end
+end
+
+# A node extension for `pair` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `pair` nodes within RuboCop.
+class RuboCop::AST::PairNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::HashElementNode
+
+  # Checks whether the `pair` uses a colon delimiter.
+  #
+  # @return [Boolean] whether this `pair` uses a colon delimiter
+  def colon?; end
+
+  # Returns the delimiter of the `pair` as a string. Returns `=>` for a
+  # colon delimited `pair` and `:` for a hash rocket delimited `pair`.
+  #
+  # @param with_spacing [Boolean] whether to include spacing
+  # @return [String] the delimiter of the `pair`
+  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
+
+  # Checks whether the `pair` uses a hash rocket delimiter.
+  #
+  # @return [Boolean] whether this `pair` uses a hash rocket delimiter
+  def hash_rocket?; end
+
+  # Returns the inverse delimiter of the `pair` as a string.
+  #
+  # @param with_spacing [Boolean] whether to include spacing
+  # @return [String] the inverse delimiter of the `pair`
+  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
+
+  # Checks whether the `pair` uses hash value omission.
+  #
+  # @return [Boolean] whether this `pair` uses hash value omission
+  def value_omission?; end
+
+  # Checks whether the value starts on its own line.
+  #
+  # @return [Boolean] whether the value in the `pair` starts its own line
+  def value_on_new_line?; end
+end
+
+RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)
+RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)
+RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)
+RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)
+
+# Requires implementing `arguments`.
+#
+# Common functionality for nodes that are parameterized:
+# `send`, `super`, `zsuper`, `def`, `defs`
+# and (modern only): `index`, `indexasgn`, `lambda`
+module RuboCop::AST::ParameterizedNode
+  # Checks whether this node has any arguments.
+  #
+  # @return [Boolean] whether this node has any arguments
+  def arguments?; end
+
+  # Whether the last argument of the node is a block pass,
+  # i.e. `&block`.
+  #
+  # @return [Boolean] whether the last argument of the node is a block pass
+  def block_argument?; end
+
+  # A shorthand for getting the first argument of the node.
+  # Equivalent to `arguments.first`.
+  #
+  # @return [Node, nil] the first argument of the node,
+  #   or `nil` if there are no arguments
+  def first_argument; end
+
+  # A shorthand for getting the last argument of the node.
+  # Equivalent to `arguments.last`.
+  #
+  # @return [Node, nil] the last argument of the node,
+  #   or `nil` if there are no arguments
+  def last_argument; end
+
+  # Checks whether this node's arguments are wrapped in parentheses.
+  #
+  # @return [Boolean] whether this node's arguments are
+  #   wrapped in parentheses
+  def parenthesized?; end
+
+  # Checks whether any argument of the node is a splat
+  # argument, i.e. `*splat`.
+  #
+  # @return [Boolean] whether the node is a splat argument
+  def rest_argument?; end
+
+  # Checks whether any argument of the node is a splat
+  # argument, i.e. `*splat`.
+  #
+  # @return [Boolean] whether the node is a splat argument
+  def splat_argument?; end
+end
+
+# A specialized `ParameterizedNode`.
+# Requires implementing `first_argument_index`
+# Implements `arguments` as `children[first_argument_index..-1]`
+# and optimizes other calls
+module RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::ParameterizedNode
+
+  # @return [Array<Node>] arguments, if any
+  def arguments; end
+
+  # Checks whether this node has any arguments.
+  #
+  # @return [Boolean] whether this node has any arguments
+  def arguments?; end
+
+  # A shorthand for getting the first argument of the node.
+  # Equivalent to `arguments.first`.
+  #
+  # @return [Node, nil] the first argument of the node,
+  #   or `nil` if there are no arguments
+  def first_argument; end
+
+  # A shorthand for getting the last argument of the node.
+  # Equivalent to `arguments.last`.
+  #
+  # @return [Node, nil] the last argument of the node,
+  #   or `nil` if there are no arguments
+  def last_argument; end
+end
+
+# A specialized `ParameterizedNode` for node that have a single child
+# containing either `nil`, an argument, or a `begin` node with all the
+# arguments
+module RuboCop::AST::ParameterizedNode::WrappedArguments
+  include ::RuboCop::AST::ParameterizedNode
+
+  # @return [Array] The arguments of the node.
+  def arguments; end
+end
+
+# Common functionality for nodes that are predicates:
+# `or`, `and` ...
+module RuboCop::AST::PredicateOperatorNode
+  # Checks whether this is a logical operator.
+  #
+  # @return [Boolean] whether this is a logical operator
+  def logical_operator?; end
+
+  # Returns the operator as a string.
+  #
+  # @return [String] the operator
+  def operator; end
+
+  # Checks whether this is a semantic operator.
+  #
+  # @return [Boolean] whether this is a semantic operator
+  def semantic_operator?; end
+end
+
+RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)
+RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)
+RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)
+RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)
+
+# A node extension for `procarg0` nodes.
+# This will be used in place of a plain node when the builder constructs
+# the AST, making its methods available to all `arg` nodes within RuboCop.
+class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode
+  # Returns the name of an argument.
+  #
+  # @return [Symbol, nil] the name of the argument
+  def name; end
+end
+
+# ProcessedSource contains objects which are generated by Parser
+# and other information such as disabled lines for cops.
+# It also provides a convenient way to access source lines.
+class RuboCop::AST::ProcessedSource
+  include ::RuboCop::Ext::ProcessedSource
+
+  # @return [ProcessedSource] a new instance of ProcessedSource
+  def initialize(source, ruby_version, path = T.unsafe(nil)); end
+
+  def [](*args); end
+
+  # Returns the value of attribute ast.
+  def ast; end
+
+  def ast_with_comments; end
+
+  # @return [Boolean]
+  def blank?; end
+
+  # Returns the value of attribute buffer.
+  def buffer; end
+
+  # Raw source checksum for tracking infinite loops.
+  def checksum; end
+
+  # @return [Comment, nil] the comment at that line, if any.
+  def comment_at_line(line); end
+
+  # Consider using `each_comment_in_lines` instead
+  #
+  # @deprecated use contains_comment?
+  # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+  def commented?(source_range); end
+
+  # Returns the value of attribute comments.
+  def comments; end
+
+  # Should have been called `comments_before_or_at_line`. Doubtful it has of any valid use.
+  #
+  # @deprecated Use `each_comment_in_lines`
+  def comments_before_line(line); end
+
+  # Consider using `each_comment_in_lines` instead
+  #
+  # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+  def contains_comment?(source_range); end
+
+  def current_line(token); end
+
+  # Returns the value of attribute diagnostics.
+  def diagnostics; end
+
+  # @deprecated Use `comments.each`
+  def each_comment(&block); end
+
+  # Enumerates on the comments contained with the given `line_range`
+  def each_comment_in_lines(line_range); end
+
+  # @deprecated Use `tokens.each`
+  def each_token(&block); end
+
+  def file_path; end
+
+  # @deprecated Use `comment_at_line`, `each_comment_in_lines`, or `comments.find`
+  def find_comment(&block); end
+
+  # @deprecated Use `tokens.find`
+  def find_token(&block); end
+
+  def first_token_of(range_or_node); end
+  def following_line(token); end
+  def last_token_of(range_or_node); end
+  def line_indentation(line_number); end
+
+  # @return [Boolean] if the given line number has a comment.
+  def line_with_comment?(line); end
+
+  # Returns the source lines, line break characters removed, excluding a
+  # possible __END__ and everything that comes after.
+  def lines; end
+
+  # Returns the value of attribute parser_error.
+  def parser_error; end
+
+  # Returns the value of attribute path.
+  def path; end
+
+  def preceding_line(token); end
+
+  # Returns the value of attribute raw_source.
+  def raw_source; end
+
+  # Returns the value of attribute ruby_version.
+  def ruby_version; end
+
+  # The tokens list is always sorted by token position, except for cases when heredoc
+  # is passed as a method argument. In this case tokens are interleaved by
+  # heredoc contents' tokens.
+  def sorted_tokens; end
+
+  # @return [Boolean]
+  def start_with?(string); end
+
+  # Returns the value of attribute tokens.
+  def tokens; end
+
+  def tokens_within(range_or_node); end
+
+  # @return [Boolean]
+  def valid_syntax?; end
+
+  private
+
+  def comment_index; end
+  def create_parser(ruby_version); end
+  def first_token_index(range_or_node); end
+  def last_token_index(range_or_node); end
+  def parse(source, ruby_version); end
+  def parser_class(ruby_version); end
+  def source_range(range_or_node); end
+  def tokenize(parser); end
+
+  class << self
+    def from_file(path, ruby_version); end
+  end
+end
+
+RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array)
+
+# @api private
+RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)
+
+# A node extension for `irange` and `erange` nodes. This will be used in
+# place of a plain node when the builder constructs the AST, making its
+# methods available to all `irange` and `erange` nodes within RuboCop.
+class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
+  def begin; end
+  def end; end
+end
+
+# A node extension for `regexp` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `regexp` nodes within RuboCop.
+class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
+  include ::RuboCop::Ext::RegexpNode
+
+  # @return [String] a string of regexp content
+  def content; end
+
+  # @return [Bool] if char is one of the delimiters
+  def delimiter?(char); end
+
+  # @return [String] the regexp delimiters (without %r)
+  def delimiters; end
+
+  # @return [Bool] if regexp uses the extended regopt
+  def extended?; end
+
+  # @return [Bool] if regexp uses the fixed-encoding regopt
+  def fixed_encoding?; end
+
+  # @return [Bool] if regexp uses the ignore-case regopt
+  def ignore_case?; end
+
+  # @return [Bool] if regexp contains interpolation
+  def interpolation?; end
+
+  # @return [Bool] if regexp uses the multiline regopt
+  def multiline_mode?; end
+
+  # @return [Bool] if regexp uses the no-encoding regopt
+  def no_encoding?; end
+
+  # NOTE: The 'o' option is ignored.
+  #
+  # @return [Integer] the Regexp option bits as returned by Regexp#options
+  def options; end
+
+  # @return [Bool] if the regexp is a %r{...} literal (using any delimiters)
+  def percent_r_literal?; end
+
+  # @return [RuboCop::AST::Node] a regopt node
+  def regopt; end
+
+  # @return [Bool] if regexp uses the single-interpolation regopt
+  def single_interpolation?; end
+
+  # @return [Bool] if the regexp is a /.../ literal
+  def slash_literal?; end
+
+  # @return [Regexp] a regexp of this node
+  def to_regexp; end
+
+  private
+
+  # @return [Boolean]
+  def regopt_include?(option); end
+end
+
+RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `resbody` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `resbody` nodes within RuboCop.
+class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
+  # Returns the body of the `rescue` clause.
+  #
+  # @return [Node, nil] The body of the `resbody`.
+  def body; end
+
+  # Returns the index of the `resbody` branch within the exception handling statement.
+  #
+  # @return [Integer] the index of the `resbody` branch
+  def branch_index; end
+
+  # Returns the exception variable of the `rescue` clause.
+  #
+  # @return [Node, nil] The exception variable of the `resbody`.
+  def exception_variable; end
+
+  # Returns an array of all the exceptions in the `rescue` clause.
+  #
+  # @return [Array<Node>] an array of exception nodes
+  def exceptions; end
+end
+
+# A node extension for `rescue` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `rescue` nodes within RuboCop.
+class RuboCop::AST::RescueNode < ::RuboCop::AST::Node
+  # Returns the body of the rescue node.
+  #
+  # @return [Node, nil] The body of the rescue node.
+  def body; end
+
+  # Returns an array of all the rescue branches in the exception handling statement.
+  #
+  # and the else (if any). Note that these bodies could be nil.
+  #
+  # @return [Array<Node, nil>] an array of the bodies of the rescue branches
+  def branches; end
+
+  # Checks whether this exception handling statement has an `else` branch.
+  #
+  # @return [Boolean] whether the exception handling statement has an `else` branch
+  def else?; end
+
+  # Returns the else branch of the exception handling statement, if any.
+  #
+  # @return [Node] the else branch node of the exception handling statement
+  # @return [nil] if the exception handling statement does not have an else branch.
+  def else_branch; end
+
+  # Returns an array of all the rescue branches in the exception handling statement.
+  #
+  # @return [Array<ResbodyNode>] an array of `resbody` nodes
+  def resbody_branches; end
+end
+
+# A node extension for `return` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `return` nodes within RuboCop.
+class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::WrappedArguments
+end
+
+# Responsible for compatibility with main gem
+#
+# @api private
+module RuboCop::AST::RuboCopCompatibility
+  # @api private
+  def rubocop_loaded; end
+end
+
+# @api private
+RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `sclass` nodes. This will be used in place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `sclass` nodes within RuboCop.
+class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
+  # The body of this `sclass` node.
+  #
+  # @return [Node, nil] the body of the class
+  def body; end
+
+  # The identifier for this `sclass` node. (Always `self`.)
+  #
+  # @return [Node] the identifier of the class
+  def identifier; end
+end
+
+# A node extension for `send` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `send` nodes within RuboCop.
+class RuboCop::AST::SendNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::ParameterizedNode::RestArguments
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  def attribute_accessor?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def first_argument_index; end
+end
+
+# This module provides a shorthand method to create a {Node} like
+# `Parser::AST::Sexp`.
+#
+# @see https://www.rubydoc.info/gems/ast/AST/Sexp
+module RuboCop::AST::Sexp
+  # Creates a {Node} with type `type` and children `children`.
+  def s(type, *children); end
+end
+
+# A node extension for `str`, `dstr`, and `xstr` nodes. This will be used
+# in place of a plain node when the builder constructs the AST, making
+# its methods available to all `str` nodes within RuboCop.
+class RuboCop::AST::StrNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+
+  # @return [Boolean]
+  def heredoc?; end
+end
+
+# A node extension for `super`- and `zsuper` nodes. This will be used in
+# place of a plain node when the builder constructs the AST, making its
+# methods available to all `super`- and `zsuper` nodes within RuboCop.
+class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  def arguments; end
+
+  # Custom destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  #
+  # @return [Array] the different parts of the `super` node
+  def node_parts; end
+end
+
+# A node extension for `sym` nodes. This will be used in  place of a
+# plain node when the builder constructs the AST, making its methods
+# available to all `sym` nodes within RuboCop.
+class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::BasicLiteralNode
+end
+
+# A basic wrapper around Parser's tokens.
+class RuboCop::AST::Token
+  # @return [Token] a new instance of Token
+  def initialize(pos, type, text); end
+
+  def begin_pos; end
+  def column; end
+
+  # @return [Boolean]
+  def comma?; end
+
+  # Type Predicates
+  #
+  # @return [Boolean]
+  def comment?; end
+
+  # @return [Boolean]
+  def dot?; end
+
+  # @return [Boolean]
+  def end?; end
+
+  def end_pos; end
+
+  # @return [Boolean]
+  def equal_sign?; end
+
+  # @return [Boolean]
+  def left_array_bracket?; end
+
+  # @return [Boolean]
+  def left_brace?; end
+
+  # @return [Boolean]
+  def left_bracket?; end
+
+  # @return [Boolean]
+  def left_curly_brace?; end
+
+  # @return [Boolean]
+  def left_parens?; end
+
+  # @return [Boolean]
+  def left_ref_bracket?; end
+
+  def line; end
+
+  # Returns the value of attribute pos.
+  def pos; end
+
+  # @return [Boolean]
+  def regexp_dots?; end
+
+  # @return [Boolean]
+  def rescue_modifier?; end
+
+  # @return [Boolean]
+  def right_bracket?; end
+
+  # @return [Boolean]
+  def right_curly_brace?; end
+
+  # @return [Boolean]
+  def right_parens?; end
+
+  # @return [Boolean]
+  def semicolon?; end
+
+  # Checks if there is whitespace after token
+  #
+  # @return [Boolean]
+  def space_after?; end
+
+  # Checks if there is whitespace before token
+  #
+  # @return [Boolean]
+  def space_before?; end
+
+  # Returns the value of attribute text.
+  def text; end
+
+  def to_s; end
+
+  # Returns the value of attribute type.
+  def type; end
+
+  class << self
+    def from_parser_token(parser_token); end
+  end
+end
+
+# Provides methods for traversing an AST.
+# Does not transform an AST; for that, use Parser::AST::Processor.
+# Override methods to perform custom processing. Remember to call `super`
+# if you want to recursively process descendant nodes.
+module RuboCop::AST::Traversal
+  extend ::RuboCop::AST::Traversal::CallbackCompiler
+
+  def on_(node); end
+  def on___ENCODING__(node); end
+  def on___FILE__(node); end
+  def on___LINE__(node); end
+  def on_alias(node); end
+  def on_and(node); end
+  def on_and_asgn(node); end
+  def on_arg(node); end
+  def on_arg_expr(node); end
+  def on_args(node); end
+  def on_array(node); end
+  def on_array_pattern(node); end
+  def on_array_pattern_with_tail(node); end
+  def on_back_ref(node); end
+  def on_begin(node); end
+  def on_block(node); end
+  def on_block_pass(node); end
+  def on_blockarg(node); end
+  def on_break(node); end
+  def on_case(node); end
+  def on_case_match(node); end
+  def on_casgn(node); end
+  def on_cbase(node); end
+  def on_class(node); end
+  def on_complex(node); end
+  def on_const(node); end
+  def on_const_pattern(node); end
+  def on_csend(node); end
+  def on_cvar(node); end
+  def on_cvasgn(node); end
+  def on_def(node); end
+  def on_defined?(node); end
+  def on_defs(node); end
+  def on_dstr(node); end
+  def on_dsym(node); end
+  def on_eflipflop(node); end
+  def on_empty_else(node); end
+  def on_ensure(node); end
+  def on_erange(node); end
+  def on_false(node); end
+  def on_find_pattern(node); end
+  def on_float(node); end
+  def on_for(node); end
+  def on_forward_arg(node); end
+  def on_forward_args(node); end
+  def on_forwarded_args(node); end
+  def on_gvar(node); end
+  def on_gvasgn(node); end
+  def on_hash(node); end
+  def on_hash_pattern(node); end
+  def on_if(node); end
+  def on_if_guard(node); end
+  def on_iflipflop(node); end
+  def on_in_match(node); end
+  def on_in_pattern(node); end
+  def on_index(node); end
+  def on_indexasgn(node); end
+  def on_int(node); end
+  def on_irange(node); end
+  def on_ivar(node); end
+  def on_ivasgn(node); end
+  def on_kwarg(node); end
+  def on_kwargs(node); end
+  def on_kwbegin(node); end
+  def on_kwnilarg(node); end
+  def on_kwoptarg(node); end
+  def on_kwrestarg(node); end
+  def on_kwsplat(node); end
+  def on_lambda(node); end
+  def on_lvar(node); end
+  def on_lvasgn(node); end
+  def on_masgn(node); end
+  def on_match_alt(node); end
+  def on_match_as(node); end
+  def on_match_current_line(node); end
+  def on_match_nil_pattern(node); end
+  def on_match_pattern(node); end
+  def on_match_pattern_p(node); end
+  def on_match_rest(node); end
+  def on_match_var(node); end
+  def on_match_with_lvasgn(node); end
+  def on_match_with_trailing_comma(node); end
+  def on_mlhs(node); end
+  def on_module(node); end
+  def on_mrasgn(node); end
+  def on_next(node); end
+  def on_nil(node); end
+  def on_not(node); end
+  def on_nth_ref(node); end
+  def on_numblock(node); end
+  def on_op_asgn(node); end
+  def on_optarg(node); end
+  def on_or(node); end
+  def on_or_asgn(node); end
+  def on_pair(node); end
+  def on_pin(node); end
+  def on_postexe(node); end
+  def on_preexe(node); end
+  def on_procarg0(node); end
+  def on_rasgn(node); end
+  def on_rational(node); end
+  def on_redo(node); end
+  def on_regexp(node); end
+  def on_regopt(node); end
+  def on_resbody(node); end
+  def on_rescue(node); end
+  def on_restarg(node); end
+  def on_retry(node); end
+  def on_return(node); end
+  def on_sclass(node); end
+  def on_self(node); end
+  def on_send(node); end
+  def on_shadowarg(node); end
+  def on_splat(node); end
+  def on_str(node); end
+  def on_super(node); end
+  def on_sym(node); end
+  def on_true(node); end
+  def on_undef(node); end
+  def on_unless_guard(node); end
+  def on_until(node); end
+  def on_until_post(node); end
+  def on_when(node); end
+  def on_while(node); end
+  def on_while_post(node); end
+  def on_xstr(node); end
+  def on_yield(node); end
+  def on_zsuper(node); end
+  def walk(node); end
+end
+
+# @api private
+module RuboCop::AST::Traversal::CallbackCompiler
+  # @api private
+  def arity_check(range); end
+
+  # @api private
+  def body(signature, prelude); end
+
+  # @api private
+  def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end
+end
+
+# @api private
+RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String)
+
+# @api private
+RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash)
+
+# Only for debugging.
+#
+# @api private
+class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end
+
+RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set)
+RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash)
+
+# A node extension for `until` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `until` nodes within RuboCop.
+class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Checks whether the `until` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `until` node has a `do` keyword
+  def do?; end
+
+  # Returns the inverse keyword of the `until` node as a string.
+  # Returns `while` for `until` nodes and vice versa.
+  #
+  # @return [String] the inverse keyword of the `until` statement
+  def inverse_keyword; end
+
+  # Returns the keyword of the `until` statement as a string.
+  #
+  # @return [String] the keyword of the `until` statement
+  def keyword; end
+end
+
+module RuboCop::AST::Version; end
+RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)
+
+# A node extension for `when` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `when` nodes within RuboCop.
+class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
+  # Returns the body of the `when` node.
+  #
+  # @return [Node, nil] the body of the `when` node
+  def body; end
+
+  # Returns the index of the `when` branch within the `case` statement.
+  #
+  # @return [Integer] the index of the `when` branch
+  def branch_index; end
+
+  # Returns an array of all the conditions in the `when` branch.
+  #
+  # @return [Array<Node>] an array of condition nodes
+  def conditions; end
+
+  # @deprecated Use `conditions.each`
+  def each_condition(&block); end
+
+  # Checks whether the `when` node has a `then` keyword.
+  #
+  # @return [Boolean] whether the `when` node has a `then` keyword
+  def then?; end
+end
+
+# A node extension for `while` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `while` nodes within RuboCop.
+class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+
+  # Checks whether the `until` node has a `do` keyword.
+  #
+  # @return [Boolean] whether the `until` node has a `do` keyword
+  def do?; end
+
+  # Returns the inverse keyword of the `while` node as a string.
+  # Returns `until` for `while` nodes and vice versa.
+  #
+  # @return [String] the inverse keyword of the `while` statement
+  def inverse_keyword; end
+
+  # Returns the keyword of the `while` statement as a string.
+  #
+  # @return [String] the keyword of the `while` statement
+  def keyword; end
+end
+
+# A node extension for `yield` nodes. This will be used in place of a plain
+# node when the builder constructs the AST, making its methods available
+# to all `yield` nodes within RuboCop.
+class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::MethodDispatchNode
+
+  def arguments; end
+
+  # Custom destructuring method. This can be used to normalize
+  # destructuring for different variations of the node.
+  #
+  # @return [Array] the different parts of the `send` node
+  def node_parts; end
+end
+
+RuboCop::NodePattern = RuboCop::AST::NodePattern
+RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
+RuboCop::Token = RuboCop::AST::Token