Gecko [ primetaxinc.net ]

Name	Size	Permission
parse_result	[ DIR ]	drwxr-xr-x
polyfill	[ DIR ]	drwxr-xr-x
translation	[ DIR ]	drwxr-xr-x
compiler.rb	15.18 KB	-rw-r--r--
desugar_compiler.rb	9.87 KB	-rw-r--r--
dispatcher.rb	111.23 KB	-rw-r--r--
dsl.rb	56.4 KB	-rw-r--r--
ffi.rb	18.45 KB	-rw-r--r--
inspect_visitor.rb	124.43 KB	-rw-r--r--
lex_compat.rb	32.42 KB	-rw-r--r--
mutation_compiler.rb	21.08 KB	-rw-r--r--
node.rb	585.16 KB	-rw-r--r--
node_ext.rb	14.94 KB	-rw-r--r--
pack.rb	5.86 KB	-rw-r--r--
parse_result.rb	27.79 KB	-rw-r--r--
pattern.rb	8.14 KB	-rw-r--r--
reflection.rb	28.7 KB	-rw-r--r--
relocation.rb	15.1 KB	-rw-r--r--
serialize.rb	83.89 KB	-rw-r--r--
string_query.rb	755 B	-rw-r--r--
translation.rb	449 B	-rw-r--r--
visitor.rb	15.4 KB	-rw-r--r--

Code Editor : node.rb

# frozen_string_literal: true

=begin
This file is generated by the templates/template.rb script and should not be
modified manually. See templates/lib/prism/node.rb.erb
if you are looking to modify the template
=end

module Prism
  # This represents a node in the tree. It is the parent class of all of the
  # various node types.
  class Node
    # A pointer to the source that this node was created from.
    attr_reader :source
    private :source

# A unique identifier for this node. This is used in a very specific
    # use case where you want to keep around a reference to a node without
    # having to keep around the syntax tree in memory. This unique identifier
    # will be consistent across multiple parses of the same source code.
    attr_reader :node_id

# Save this node using a saved source so that it can be retrieved later.
    def save(repository)
      repository.enter(node_id, :itself)
    end

# A Location instance that represents the location of this node in the
    # source.
    def location
      location = @location
      return location if location.is_a?(Location)
      @location = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the location using a saved source so that it can be retrieved later.
    def save_location(repository)
      repository.enter(node_id, :location)
    end

# Delegates to the start_line of the associated location object.
    def start_line
      location.start_line
    end

# Delegates to the end_line of the associated location object.
    def end_line
      location.end_line
    end

# The start offset of the node in the source. This method is effectively a
    # delegate method to the location object.
    def start_offset
      location = @location
      location.is_a?(Location) ? location.start_offset : location >> 32
    end

# The end offset of the node in the source. This method is effectively a
    # delegate method to the location object.
    def end_offset
      location = @location
      location.is_a?(Location) ? location.end_offset : ((location >> 32) + (location & 0xFFFFFFFF))
    end

# Delegates to the start_character_offset of the associated location object.
    def start_character_offset
      location.start_character_offset
    end

# Delegates to the end_character_offset of the associated location object.
    def end_character_offset
      location.end_character_offset
    end

# Delegates to the cached_start_code_units_offset of the associated location
    # object.
    def cached_start_code_units_offset(cache)
      location.cached_start_code_units_offset(cache)
    end

# Delegates to the cached_end_code_units_offset of the associated location
    # object.
    def cached_end_code_units_offset(cache)
      location.cached_end_code_units_offset(cache)
    end

# Delegates to the start_column of the associated location object.
    def start_column
      location.start_column
    end

# Delegates to the end_column of the associated location object.
    def end_column
      location.end_column
    end

# Delegates to the start_character_column of the associated location object.
    def start_character_column
      location.start_character_column
    end

# Delegates to the end_character_column of the associated location object.
    def end_character_column
      location.end_character_column
    end

# Delegates to the cached_start_code_units_column of the associated location
    # object.
    def cached_start_code_units_column(cache)
      location.cached_start_code_units_column(cache)
    end

# Delegates to the cached_end_code_units_column of the associated location
    # object.
    def cached_end_code_units_column(cache)
      location.cached_end_code_units_column(cache)
    end

# Delegates to the leading_comments of the associated location object.
    def leading_comments
      location.leading_comments
    end

# Delegates to the trailing_comments of the associated location object.
    def trailing_comments
      location.trailing_comments
    end

# Delegates to the comments of the associated location object.
    def comments
      location.comments
    end

# Returns all of the lines of the source code associated with this node.
    def source_lines
      location.source_lines
    end

# An alias for source_lines, used to mimic the API from
    # RubyVM::AbstractSyntaxTree to make it easier to migrate.
    alias script_lines source_lines

# Slice the location of the node from the source.
    def slice
      location.slice
    end

# Slice the location of the node from the source, starting at the beginning
    # of the line that the location starts on, ending at the end of the line
    # that the location ends on.
    def slice_lines
      location.slice_lines
    end

# An bitset of flags for this node. There are certain flags that are common
    # for all nodes, and then some nodes have specific flags.
    attr_reader :flags
    protected :flags

# Returns true if the node has the newline flag set.
    def newline?
      flags.anybits?(NodeFlags::NEWLINE)
    end

# Returns true if the node has the static literal flag set.
    def static_literal?
      flags.anybits?(NodeFlags::STATIC_LITERAL)
    end

# Similar to inspect, but respects the current level of indentation given by
    # the pretty print object.
    def pretty_print(q)
      q.seplist(inspect.chomp.each_line, -> { q.breakable }) do |line|
        q.text(line.chomp)
      end
      q.current_group.break
    end

# Convert this node into a graphviz dot graph string.
    def to_dot
      # @type self: node
      DotVisitor.new.tap { |visitor| accept(visitor) }.to_dot
    end

# Returns a list of nodes that are descendants of this node that contain the
    # given line and column. This is useful for locating a node that is selected
    # based on the line and column of the source code.
    #
    # Important to note is that the column given to this method should be in
    # bytes, as opposed to characters or code units.
    def tunnel(line, column)
      queue = [self] #: Array[Prism::node]
      result = [] #: Array[Prism::node]

while (node = queue.shift)
        result << node

node.compact_child_nodes.each do |child_node|
          child_location = child_node.location

start_line = child_location.start_line
          end_line = child_location.end_line

if start_line == end_line
            if line == start_line && column >= child_location.start_column && column < child_location.end_column
              queue << child_node
              break
            end
          elsif (line == start_line && column >= child_location.start_column) || (line == end_line && column < child_location.end_column)
            queue << child_node
            break
          elsif line > start_line && line < end_line
            queue << child_node
            break
          end
        end
      end

result
    end

# Returns the first node that matches the given block when visited in a
    # depth-first search. This is useful for finding a node that matches a
    # particular condition.
    #
    #     node.breadth_first_search { |node| node.node_id == node_id }
    #
    def breadth_first_search(&block)
      queue = [self] #: Array[Prism::node]

while (node = queue.shift)
        return node if yield node
        queue.concat(node.compact_child_nodes)
      end

nil
    end

# Returns a list of the fields that exist for this node class. Fields
    # describe the structure of the node. This kind of reflection is useful for
    # things like recursively visiting each node _and_ field in the tree.
    def self.fields
      # This method should only be called on subclasses of Node, not Node
      # itself.
      raise NoMethodError, "undefined method `fields' for #{inspect}" if self == Node

Reflection.fields_for(self)
    end

# --------------------------------------------------------------------------
    # :section: Node interface
    # These methods are effectively abstract methods that must be implemented by
    # the various subclasses of Node. They are here to make it easier to work
    # with typecheckers.
    # --------------------------------------------------------------------------

# Accepts a visitor and calls back into the specialized visit function.
    def accept(visitor)
      raise NoMethodError, "undefined method `accept' for #{inspect}"
    end

# Returns an array of child nodes, including `nil`s in the place of optional
    # nodes that were not present.
    def child_nodes
      raise NoMethodError, "undefined method `child_nodes' for #{inspect}"
    end

alias deconstruct child_nodes

# Returns an array of child nodes, excluding any `nil`s in the place of
    # optional nodes that were not present.
    def compact_child_nodes
      raise NoMethodError, "undefined method `compact_child_nodes' for #{inspect}"
    end

# Returns an array of child nodes and locations that could potentially have
    # comments attached to them.
    def comment_targets
      raise NoMethodError, "undefined method `comment_targets' for #{inspect}"
    end

# Returns a string representation of the node.
    def inspect
      raise NoMethodError, "undefined method `inspect' for #{inspect}"
    end

# Sometimes you want to check an instance of a node against a list of
    # classes to see what kind of behavior to perform. Usually this is done by
    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
    # case statement and doing `case node; when cls1; when cls2; end`. Both of
    # these approaches are relatively slow because of the constant lookups,
    # method calls, and/or array allocations.
    #
    # Instead, you can call #type, which will return to you a symbol that you
    # can use for comparison. This is faster than the other approaches because
    # it uses a single integer comparison, but also because if you're on CRuby
    # you can take advantage of the fact that case statements with all symbol
    # keys will use a jump table.
    def type
      raise NoMethodError, "undefined method `type' for #{inspect}"
    end

# Similar to #type, this method returns a symbol that you can use for
    # splitting on the type of the node without having to do a long === chain.
    # Note that like #type, it will still be slower than using == for a single
    # class, but should be faster in a case statement or an array comparison.
    def self.type
      raise NoMethodError, "undefined method `type' for #{inspect}"
    end
  end

# Represents the use of the `alias` keyword to alias a global variable.
  #
  #     alias $foo $bar
  #     ^^^^^^^^^^^^^^^
  class AliasGlobalVariableNode < Node
    # Initialize a new AliasGlobalVariableNode node.
    def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @new_name = new_name
      @old_name = old_name
      @keyword_loc = keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_alias_global_variable_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [new_name, old_name]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [new_name, old_name]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [new_name, old_name, keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, new_name: self.new_name, old_name: self.old_name, keyword_loc: self.keyword_loc)
      AliasGlobalVariableNode.new(source, node_id, location, flags, new_name, old_name, keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, new_name: new_name, old_name: old_name, keyword_loc: keyword_loc }
    end

# Represents the new name of the global variable that can be used after aliasing.
    #
    #     alias $foo $bar
    #           ^^^^
    attr_reader :new_name

# Represents the old name of the global variable that can be used before aliasing.
    #
    #     alias $foo $bar
    #                ^^^^
    attr_reader :old_name

# The location of the `alias` keyword.
    #
    #     alias $foo $bar
    #     ^^^^^
    def keyword_loc
      location = @keyword_loc
      return location if location.is_a?(Location)
      @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_keyword_loc(repository)
      repository.enter(node_id, :keyword_loc)
    end

# def keyword: () -> String
    def keyword
      keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :alias_global_variable_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :alias_global_variable_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(AliasGlobalVariableNode) &&
        (new_name === other.new_name) &&
        (old_name === other.old_name) &&
        (keyword_loc.nil? == other.keyword_loc.nil?)
    end
  end

# Represents the use of the `alias` keyword to alias a method.
  #
  #     alias foo bar
  #     ^^^^^^^^^^^^^
  class AliasMethodNode < Node
    # Initialize a new AliasMethodNode node.
    def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @new_name = new_name
      @old_name = old_name
      @keyword_loc = keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_alias_method_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [new_name, old_name]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [new_name, old_name]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [new_name, old_name, keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, new_name: self.new_name, old_name: self.old_name, keyword_loc: self.keyword_loc)
      AliasMethodNode.new(source, node_id, location, flags, new_name, old_name, keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, new_name: new_name, old_name: old_name, keyword_loc: keyword_loc }
    end

# Represents the new name of the method that will be aliased.
    #
    #     alias foo bar
    #           ^^^
    #
    #     alias :foo :bar
    #           ^^^^
    #
    #     alias :"#{foo}" :"#{bar}"
    #           ^^^^^^^^^
    attr_reader :new_name

# Represents the old name of the method that will be aliased.
    #
    #     alias foo bar
    #               ^^^
    #
    #     alias :foo :bar
    #                ^^^^
    #
    #     alias :"#{foo}" :"#{bar}"
    #                     ^^^^^^^^^
    attr_reader :old_name

# Represents the location of the `alias` keyword.
    #
    #     alias foo bar
    #     ^^^^^
    def keyword_loc
      location = @keyword_loc
      return location if location.is_a?(Location)
      @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_keyword_loc(repository)
      repository.enter(node_id, :keyword_loc)
    end

# def keyword: () -> String
    def keyword
      keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :alias_method_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :alias_method_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(AliasMethodNode) &&
        (new_name === other.new_name) &&
        (old_name === other.old_name) &&
        (keyword_loc.nil? == other.keyword_loc.nil?)
    end
  end

# Represents an alternation pattern in pattern matching.
  #
  #     foo => bar | baz
  #            ^^^^^^^^^
  class AlternationPatternNode < Node
    # Initialize a new AlternationPatternNode node.
    def initialize(source, node_id, location, flags, left, right, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @left = left
      @right = right
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_alternation_pattern_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [left, right]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [left, right]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [left, right, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, left: self.left, right: self.right, operator_loc: self.operator_loc)
      AlternationPatternNode.new(source, node_id, location, flags, left, right, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, left: left, right: right, operator_loc: operator_loc }
    end

# Represents the left side of the expression.
    #
    #     foo => bar | baz
    #            ^^^
    attr_reader :left

# Represents the right side of the expression.
    #
    #     foo => bar | baz
    #                  ^^^
    attr_reader :right

# Represents the alternation operator location.
    #
    #     foo => bar | baz
    #                ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :alternation_pattern_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :alternation_pattern_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(AlternationPatternNode) &&
        (left === other.left) &&
        (right === other.right) &&
        (operator_loc.nil? == other.operator_loc.nil?)
    end
  end

# Represents the use of the `&&` operator or the `and` keyword.
  #
  #     left and right
  #     ^^^^^^^^^^^^^^
  class AndNode < Node
    # Initialize a new AndNode node.
    def initialize(source, node_id, location, flags, left, right, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @left = left
      @right = right
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_and_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [left, right]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [left, right]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [left, right, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, left: self.left, right: self.right, operator_loc: self.operator_loc)
      AndNode.new(source, node_id, location, flags, left, right, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     left and right
    #     ^^^^
    #
    #     1 && 2
    #     ^
    attr_reader :left

# Represents the right side of the expression.
    #
    #     left && right
    #             ^^^^^
    #
    #     1 and 2
    #           ^
    attr_reader :right

# The location of the `and` keyword or the `&&` operator.
    #
    #     left and right
    #          ^^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :and_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :and_node
    end

# Represents a set of arguments to a method or a keyword.
  #
  #     return foo, bar, baz
  #            ^^^^^^^^^^^^^
  class ArgumentsNode < Node
    # Initialize a new ArgumentsNode node.
    def initialize(source, node_id, location, flags, arguments)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @arguments = arguments
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_arguments_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [*arguments]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [*arguments]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*arguments] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, arguments: self.arguments)
      ArgumentsNode.new(source, node_id, location, flags, arguments)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, arguments: arguments }
    end

# def contains_forwarding?: () -> bool
    def contains_forwarding?
      flags.anybits?(ArgumentsNodeFlags::CONTAINS_FORWARDING)
    end

# def contains_keywords?: () -> bool
    def contains_keywords?
      flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORDS)
    end

# def contains_keyword_splat?: () -> bool
    def contains_keyword_splat?
      flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT)
    end

# def contains_splat?: () -> bool
    def contains_splat?
      flags.anybits?(ArgumentsNodeFlags::CONTAINS_SPLAT)
    end

# def contains_multiple_splats?: () -> bool
    def contains_multiple_splats?
      flags.anybits?(ArgumentsNodeFlags::CONTAINS_MULTIPLE_SPLATS)
    end

# The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo(bar, baz)
    #         ^^^^^^^^
    attr_reader :arguments

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :arguments_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :arguments_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ArgumentsNode) &&
        (flags === other.flags) &&
        (arguments.length == other.arguments.length) &&
        arguments.zip(other.arguments).all? { |left, right| left === right }
    end
  end

# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
  #
  #     [1, 2, 3]
  #     ^^^^^^^^^
  class ArrayNode < Node
    # Initialize a new ArrayNode node.
    def initialize(source, node_id, location, flags, elements, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @elements = elements
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_array_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [*elements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [*elements]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*elements, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, elements: self.elements, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      ArrayNode.new(source, node_id, location, flags, elements, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, elements: elements, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# def contains_splat?: () -> bool
    def contains_splat?
      flags.anybits?(ArrayNodeFlags::CONTAINS_SPLAT)
    end

# Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
    attr_reader :elements

# Represents the optional source location for the opening token.
    #
    #     [1,2,3]                 # "["
    #     %w[foo bar baz]         # "%w["
    #     %I(apple orange banana) # "%I("
    #     foo = 1, 2, 3           # nil
    def opening_loc
      location = @opening_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the opening_loc location using the given saved source so that
    # it can be retrieved later.
    def save_opening_loc(repository)
      repository.enter(node_id, :opening_loc) unless @opening_loc.nil?
    end

# Represents the optional source location for the closing token.
    #
    #     [1,2,3]                 # "]"
    #     %w[foo bar baz]         # "]"
    #     %I(apple orange banana) # ")"
    #     foo = 1, 2, 3           # nil
    def closing_loc
      location = @closing_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the closing_loc location using the given saved source so that
    # it can be retrieved later.
    def save_closing_loc(repository)
      repository.enter(node_id, :closing_loc) unless @closing_loc.nil?
    end

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :array_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :array_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ArrayNode) &&
        (flags === other.flags) &&
        (elements.length == other.elements.length) &&
        elements.zip(other.elements).all? { |left, right| left === right } &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents an array pattern in pattern matching.
  #
  #     foo in 1, 2
  #     ^^^^^^^^^^^
  #
  #     foo in [1, 2]
  #     ^^^^^^^^^^^^^
  #
  #     foo in *bar
  #     ^^^^^^^^^^^
  #
  #     foo in Bar[]
  #     ^^^^^^^^^^^^
  #
  #     foo in Bar[1, 2, 3]
  #     ^^^^^^^^^^^^^^^^^^^
  class ArrayPatternNode < Node
    # Initialize a new ArrayPatternNode node.
    def initialize(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @constant = constant
      @requireds = requireds
      @rest = rest
      @posts = posts
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_array_pattern_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [constant, *requireds, rest, *posts]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << constant if constant
      compact.concat(requireds)
      compact << rest if rest
      compact.concat(posts)
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*constant, *requireds, *rest, *posts, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, requireds: self.requireds, rest: self.rest, posts: self.posts, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      ArrayPatternNode.new(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, constant: constant, requireds: requireds, rest: rest, posts: posts, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# attr_reader constant: ConstantReadNode | ConstantPathNode | nil
    attr_reader :constant

# Represents the required elements of the array pattern.
    #
    #     foo in [1, 2]
    #             ^  ^
    attr_reader :requireds

# Represents the rest element of the array pattern.
    #
    #     foo in *bar
    #            ^^^^
    attr_reader :rest

# Represents the elements after the rest element of the array pattern.
    #
    #     foo in *bar, baz
    #                  ^^^
    attr_reader :posts

# Represents the opening location of the array pattern.
    #
    #     foo in [1, 2]
    #            ^
    def opening_loc
      location = @opening_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the closing location of the array pattern.
    #
    #     foo in [1, 2]
    #                 ^
    def closing_loc
      location = @closing_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :array_pattern_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :array_pattern_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ArrayPatternNode) &&
        (constant === other.constant) &&
        (requireds.length == other.requireds.length) &&
        requireds.zip(other.requireds).all? { |left, right| left === right } &&
        (rest === other.rest) &&
        (posts.length == other.posts.length) &&
        posts.zip(other.posts).all? { |left, right| left === right } &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents a hash key/value pair.
  #
  #     { a => b }
  #       ^^^^^^
  class AssocNode < Node
    # Initialize a new AssocNode node.
    def initialize(source, node_id, location, flags, key, value, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @key = key
      @value = value
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_assoc_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [key, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [key, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [key, value, *operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, key: self.key, value: self.value, operator_loc: self.operator_loc)
      AssocNode.new(source, node_id, location, flags, key, value, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, key: key, value: value, operator_loc: operator_loc }
    end

# The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     { a: b }
    #       ^
    #
    #     { foo => bar }
    #       ^^^
    #
    #     { def a; end => 1 }
    #       ^^^^^^^^^^
    attr_reader :key

# The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     { foo => bar }
    #              ^^^
    #
    #     { x: 1 }
    #          ^
    attr_reader :value

# The location of the `=>` operator, if present.
    #
    #     { foo => bar }
    #           ^^
    def operator_loc
      location = @operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc) unless @operator_loc.nil?
    end

# def operator: () -> String?
    def operator
      operator_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :assoc_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :assoc_node
    end

# Represents a splat in a hash literal.
  #
  #     { **foo }
  #       ^^^^^
  class AssocSplatNode < Node
    # Initialize a new AssocSplatNode node.
    def initialize(source, node_id, location, flags, value, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @value = value
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_assoc_splat_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << value if value
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*value, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value, operator_loc: self.operator_loc)
      AssocSplatNode.new(source, node_id, location, flags, value, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, value: value, operator_loc: operator_loc }
    end

# The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
    #
    #     { **foo }
    #         ^^^
    attr_reader :value

# The location of the `**` operator.
    #
    #     { **x }
    #       ^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :assoc_splat_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :assoc_splat_node
    end

# Represents reading a reference to a field in the previous match.
  #
  #     $'
  #     ^^
  class BackReferenceReadNode < Node
    # Initialize a new BackReferenceReadNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_back_reference_read_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      BackReferenceReadNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name }
    end

# The name of the back-reference variable, including the leading `$`.
    #
    #     $& # name `:$&`
    #
    #     $+ # name `:$+`
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :back_reference_read_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :back_reference_read_node
    end

# Represents a begin statement.
  #
  #     begin
  #       foo
  #     end
  #     ^^^^^
  class BeginNode < Node
    # Initialize a new BeginNode node.
    def initialize(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @begin_keyword_loc = begin_keyword_loc
      @statements = statements
      @rescue_clause = rescue_clause
      @else_clause = else_clause
      @ensure_clause = ensure_clause
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_begin_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [statements, rescue_clause, else_clause, ensure_clause]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << statements if statements
      compact << rescue_clause if rescue_clause
      compact << else_clause if else_clause
      compact << ensure_clause if ensure_clause
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*begin_keyword_loc, *statements, *rescue_clause, *else_clause, *ensure_clause, *end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, begin_keyword_loc: self.begin_keyword_loc, statements: self.statements, rescue_clause: self.rescue_clause, else_clause: self.else_clause, ensure_clause: self.ensure_clause, end_keyword_loc: self.end_keyword_loc)
      BeginNode.new(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, begin_keyword_loc: begin_keyword_loc, statements: statements, rescue_clause: rescue_clause, else_clause: else_clause, ensure_clause: ensure_clause, end_keyword_loc: end_keyword_loc }
    end

# Represents the location of the `begin` keyword.
    #
    #     begin x end
    #     ^^^^^
    def begin_keyword_loc
      location = @begin_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @begin_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the begin_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_begin_keyword_loc(repository)
      repository.enter(node_id, :begin_keyword_loc) unless @begin_keyword_loc.nil?
    end

# Represents the statements within the begin block.
    #
    #     begin x end
    #           ^
    attr_reader :statements

# Represents the rescue clause within the begin block.
    #
    #     begin x; rescue y; end
    #              ^^^^^^^^
    attr_reader :rescue_clause

# Represents the else clause within the begin block.
    #
    #     begin x; rescue y; else z; end
    #                        ^^^^^^
    attr_reader :else_clause

# Represents the ensure clause within the begin block.
    #
    #     begin x; ensure y; end
    #              ^^^^^^^^
    attr_reader :ensure_clause

# Represents the location of the `end` keyword.
    #
    #     begin x end
    #             ^^^
    def end_keyword_loc
      location = @end_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the end_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_end_keyword_loc(repository)
      repository.enter(node_id, :end_keyword_loc) unless @end_keyword_loc.nil?
    end

# def begin_keyword: () -> String?
    def begin_keyword
      begin_keyword_loc&.slice
    end

# def end_keyword: () -> String?
    def end_keyword
      end_keyword_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :begin_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :begin_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(BeginNode) &&
        (begin_keyword_loc.nil? == other.begin_keyword_loc.nil?) &&
        (statements === other.statements) &&
        (rescue_clause === other.rescue_clause) &&
        (else_clause === other.else_clause) &&
        (ensure_clause === other.ensure_clause) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents a block argument using `&`.
  #
  #     bar(&args)
  #     ^^^^^^^^^^
  class BlockArgumentNode < Node
    # Initialize a new BlockArgumentNode node.
    def initialize(source, node_id, location, flags, expression, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @expression = expression
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_block_argument_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [expression]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << expression if expression
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*expression, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, expression: self.expression, operator_loc: self.operator_loc)
      BlockArgumentNode.new(source, node_id, location, flags, expression, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, expression: expression, operator_loc: operator_loc }
    end

# The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo(&args)
    #         ^^^^^
    attr_reader :expression

# Represents the location of the `&` operator.
    #
    #     foo(&args)
    #         ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :block_argument_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :block_argument_node
    end

# Represents a block local variable.
  #
  #     a { |; b| }
  #            ^
  class BlockLocalVariableNode < Node
    # Initialize a new BlockLocalVariableNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_block_local_variable_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      BlockLocalVariableNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def repeated_parameter?: () -> bool
    def repeated_parameter?
      flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
    end

# The name of the block local variable.
    #
    #     a { |; b| } # name `:b`
    #            ^
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :block_local_variable_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :block_local_variable_node
    end

# Represents a block of ruby code.
  #
  #     [1, 2, 3].each { |i| puts x }
  #                    ^^^^^^^^^^^^^^
  class BlockNode < Node
    # Initialize a new BlockNode node.
    def initialize(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @locals = locals
      @parameters = parameters
      @body = body
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_block_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [parameters, body]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << parameters if parameters
      compact << body if body
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*parameters, *body, opening_loc, closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, parameters: self.parameters, body: self.body, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      BlockNode.new(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, locals: locals, parameters: parameters, body: body, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# The local variables declared in the block.
    #
    #     [1, 2, 3].each { |i| puts x } # locals: [:i]
    #                       ^
    attr_reader :locals

# The parameters of the block.
    #
    #     [1, 2, 3].each { |i| puts x }
    #                      ^^^
    #     [1, 2, 3].each { puts _1 }
    #                    ^^^^^^^^^^^
    #     [1, 2, 3].each { puts it }
    #                    ^^^^^^^^^^^
    attr_reader :parameters

# The body of the block.
    #
    #     [1, 2, 3].each { |i| puts x }
    #                          ^^^^^^
    attr_reader :body

# Represents the location of the opening `|`.
    #
    #     [1, 2, 3].each { |i| puts x }
    #                      ^
    def opening_loc
      location = @opening_loc
      return location if location.is_a?(Location)
      @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the opening_loc location using the given saved source so that
    # it can be retrieved later.
    def save_opening_loc(repository)
      repository.enter(node_id, :opening_loc)
    end

# Represents the location of the closing `|`.
    #
    #     [1, 2, 3].each { |i| puts x }
    #                        ^
    def closing_loc
      location = @closing_loc
      return location if location.is_a?(Location)
      @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the closing_loc location using the given saved source so that
    # it can be retrieved later.
    def save_closing_loc(repository)
      repository.enter(node_id, :closing_loc)
    end

# def opening: () -> String
    def opening
      opening_loc.slice
    end

# def closing: () -> String
    def closing
      closing_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :block_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :block_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(BlockNode) &&
        (locals.length == other.locals.length) &&
        locals.zip(other.locals).all? { |left, right| left === right } &&
        (parameters === other.parameters) &&
        (body === other.body) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents a block parameter of a method, block, or lambda definition.
  #
  #     def a(&b)
  #           ^^
  #     end
  class BlockParameterNode < Node
    # Initialize a new BlockParameterNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_block_parameter_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*name_loc, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc)
      BlockParameterNode.new(source, node_id, location, flags, name, name_loc, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name, name_loc: name_loc, operator_loc: operator_loc }
    end

# def repeated_parameter?: () -> bool
    def repeated_parameter?
      flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
    end

# The name of the block parameter.
    #
    #     def a(&b) # name `:b`
    #            ^
    #     end
    attr_reader :name

# Represents the location of the block parameter name.
    #
    #     def a(&b)
    #            ^
    def name_loc
      location = @name_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc) unless @name_loc.nil?
    end

# Represents the location of the `&` operator.
    #
    #     def a(&b)
    #           ^
    #     end
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :block_parameter_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :block_parameter_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(BlockParameterNode) &&
        (flags === other.flags) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (operator_loc.nil? == other.operator_loc.nil?)
    end
  end

# Represents a block's parameters declaration.
  #
  #     -> (a, b = 1; local) { }
  #        ^^^^^^^^^^^^^^^^^
  #
  #     foo do |a, b = 1; local|
  #            ^^^^^^^^^^^^^^^^^
  #     end
  class BlockParametersNode < Node
    # Initialize a new BlockParametersNode node.
    def initialize(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @parameters = parameters
      @locals = locals
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_block_parameters_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [parameters, *locals]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << parameters if parameters
      compact.concat(locals)
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*parameters, *locals, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, parameters: self.parameters, locals: self.locals, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      BlockParametersNode.new(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, parameters: parameters, locals: locals, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# Represents the parameters of the block.
    #
    #     -> (a, b = 1; local) { }
    #         ^^^^^^^^
    #
    #     foo do |a, b = 1; local|
    #             ^^^^^^^^
    #     end
    attr_reader :parameters

# Represents the local variables of the block.
    #
    #     -> (a, b = 1; local) { }
    #                   ^^^^^
    #
    #     foo do |a, b = 1; local|
    #                       ^^^^^
    #     end
    attr_reader :locals

# Represents the opening location of the block parameters.
    #
    #     -> (a, b = 1; local) { }
    #        ^
    #
    #     foo do |a, b = 1; local|
    #            ^
    #     end
    def opening_loc
      location = @opening_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the closing location of the block parameters.
    #
    #     -> (a, b = 1; local) { }
    #                        ^
    #
    #     foo do |a, b = 1; local|
    #                            ^
    #     end
    def closing_loc
      location = @closing_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :block_parameters_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :block_parameters_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(BlockParametersNode) &&
        (parameters === other.parameters) &&
        (locals.length == other.locals.length) &&
        locals.zip(other.locals).all? { |left, right| left === right } &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents the use of the `break` keyword.
  #
  #     break foo
  #     ^^^^^^^^^
  class BreakNode < Node
    # Initialize a new BreakNode node.
    def initialize(source, node_id, location, flags, arguments, keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @arguments = arguments
      @keyword_loc = keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_break_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [arguments]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << arguments if arguments
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*arguments, keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, arguments: self.arguments, keyword_loc: self.keyword_loc)
      BreakNode.new(source, node_id, location, flags, arguments, keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, arguments: arguments, keyword_loc: keyword_loc }
    end

# The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     break foo
    #           ^^^
    attr_reader :arguments

# The location of the `break` keyword.
    #
    #     break foo
    #     ^^^^^
    def keyword_loc
      location = @keyword_loc
      return location if location.is_a?(Location)
      @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_keyword_loc(repository)
      repository.enter(node_id, :keyword_loc)
    end

# def keyword: () -> String
    def keyword
      keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :break_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :break_node
    end

# Represents the use of the `&&=` operator on a call.
  #
  #     foo.bar &&= value
  #     ^^^^^^^^^^^^^^^^^
  class CallAndWriteNode < Node
    # Initialize a new CallAndWriteNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @message_loc = message_loc
      @read_name = read_name
      @write_name = write_name
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_call_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << receiver if receiver
      compact << value
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, *message_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, operator_loc: self.operator_loc, value: self.value)
      CallAndWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value }
    end

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo.bar &&= value
    #     ^^^
    attr_reader :receiver

# Represents the location of the call operator.
    #
    #     foo.bar &&= value
    #        ^
    def call_operator_loc
      location = @call_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the call_operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_call_operator_loc(repository)
      repository.enter(node_id, :call_operator_loc) unless @call_operator_loc.nil?
    end

# Represents the location of the message.
    #
    #     foo.bar &&= value
    #         ^^^
    def message_loc
      location = @message_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the message_loc location using the given saved source so that
    # it can be retrieved later.
    def save_message_loc(repository)
      repository.enter(node_id, :message_loc) unless @message_loc.nil?
    end

# Represents the name of the method being called.
    #
    #     foo.bar &&= value # read_name `:bar`
    #         ^^^
    attr_reader :read_name

# Represents the name of the method being written to.
    #
    #     foo.bar &&= value # write_name `:bar=`
    #         ^^^
    attr_reader :write_name

# Represents the location of the operator.
    #
    #     foo.bar &&= value
    #             ^^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# Represents the value being assigned.
    #
    #     foo.bar &&= value
    #                 ^^^^^
    attr_reader :value

# def call_operator: () -> String?
    def call_operator
      call_operator_loc&.slice
    end

# def message: () -> String?
    def message
      message_loc&.slice
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :call_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :call_and_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CallAndWriteNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (message_loc.nil? == other.message_loc.nil?) &&
        (read_name === other.read_name) &&
        (write_name === other.write_name) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents a method call, in all of the various forms that can take.
  #
  #     foo
  #     ^^^
  #
  #     foo()
  #     ^^^^^
  #
  #     +foo
  #     ^^^^
  #
  #     foo + bar
  #     ^^^^^^^^^
  #
  #     foo.bar
  #     ^^^^^^^
  #
  #     foo&.bar
  #     ^^^^^^^^
  class CallNode < Node
    # Initialize a new CallNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @name = name
      @message_loc = message_loc
      @opening_loc = opening_loc
      @arguments = arguments
      @closing_loc = closing_loc
      @block = block
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_call_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, arguments, block]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << receiver if receiver
      compact << arguments if arguments
      compact << block if block
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *block] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block }
    end

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# Represents the location of the call operator.
    #
    #     foo.bar
    #        ^
    #
    #     foo&.bar
    #        ^^
    def call_operator_loc
      location = @call_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the name of the method being called.
    #
    #     foo.bar # name `:foo`
    #     ^^^
    attr_reader :name

# Represents the location of the message.
    #
    #     foo.bar
    #         ^^^
    def message_loc
      location = @message_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the location of the left parenthesis.
    #     foo(bar)
    #        ^
    def opening_loc
      location = @opening_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo(bar)
    #         ^^^
    attr_reader :arguments

# Represents the location of the right parenthesis.
    #
    #     foo(bar)
    #            ^
    def closing_loc
      location = @closing_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the block that is being passed to the method.
    #
    #     foo { |a| a }
    #         ^^^^^^^^^
    attr_reader :block

# def call_operator: () -> String?
    def call_operator
      call_operator_loc&.slice
    end

# def message: () -> String?
    def message
      message_loc&.slice
    end

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :call_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :call_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CallNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (name === other.name) &&
        (message_loc.nil? == other.message_loc.nil?) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (arguments === other.arguments) &&
        (closing_loc.nil? == other.closing_loc.nil?) &&
        (block === other.block)
    end
  end

# Represents the use of an assignment operator on a call.
  #
  #     foo.bar += baz
  #     ^^^^^^^^^^^^^^
  class CallOperatorWriteNode < Node
    # Initialize a new CallOperatorWriteNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @message_loc = message_loc
      @read_name = read_name
      @write_name = write_name
      @binary_operator = binary_operator
      @binary_operator_loc = binary_operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_call_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << receiver if receiver
      compact << value
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, *message_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value)
      CallOperatorWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, binary_operator: binary_operator, binary_operator_loc: binary_operator_loc, value: value }
    end

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo.bar += value
    #     ^^^
    attr_reader :receiver

# Represents the location of the call operator.
    #
    #     foo.bar += value
    #        ^
    def call_operator_loc
      location = @call_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the location of the message.
    #
    #     foo.bar += value
    #         ^^^
    def message_loc
      location = @message_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the name of the method being called.
    #
    #     foo.bar += value # read_name `:bar`
    #         ^^^
    attr_reader :read_name

# Represents the name of the method being written to.
    #
    #     foo.bar += value # write_name `:bar=`
    #         ^^^
    attr_reader :write_name

# Represents the binary operator being used.
    #
    #     foo.bar += value # binary_operator `:+`
    #             ^
    attr_reader :binary_operator

# Represents the location of the binary operator.
    #
    #     foo.bar += value
    #             ^^
    def binary_operator_loc
      location = @binary_operator_loc
      return location if location.is_a?(Location)
      @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the binary_operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_binary_operator_loc(repository)
      repository.enter(node_id, :binary_operator_loc)
    end

# Represents the value being assigned.
    #
    #     foo.bar += value
    #                ^^^^^
    attr_reader :value

# def call_operator: () -> String?
    def call_operator
      call_operator_loc&.slice
    end

# def message: () -> String?
    def message
      message_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :call_operator_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :call_operator_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CallOperatorWriteNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (message_loc.nil? == other.message_loc.nil?) &&
        (read_name === other.read_name) &&
        (write_name === other.write_name) &&
        (binary_operator === other.binary_operator) &&
        (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents the use of the `||=` operator on a call.
  #
  #     foo.bar ||= value
  #     ^^^^^^^^^^^^^^^^^
  class CallOrWriteNode < Node
    # Initialize a new CallOrWriteNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @message_loc = message_loc
      @read_name = read_name
      @write_name = write_name
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_call_or_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << receiver if receiver
      compact << value
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, *message_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, operator_loc: self.operator_loc, value: self.value)
      CallOrWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# Represents the location of the call operator.
    #
    #     foo.bar ||= value
    #        ^
    def call_operator_loc
      location = @call_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the location of the message.
    #
    #     foo.bar ||= value
    #         ^^^
    def message_loc
      location = @message_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Represents the name of the method being called.
    #
    #     foo.bar ||= value # read_name `:bar`
    #         ^^^
    attr_reader :read_name

# Represents the name of the method being written to.
    #
    #     foo.bar ||= value # write_name `:bar=`
    #         ^^^
    attr_reader :write_name

# Represents the location of the operator.
    #
    #     foo.bar ||= value
    #             ^^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# Represents the value being assigned.
    #
    #     foo.bar ||= value
    #                 ^^^^^
    attr_reader :value

# def call_operator: () -> String?
    def call_operator
      call_operator_loc&.slice
    end

# def message: () -> String?
    def message
      message_loc&.slice
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :call_or_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :call_or_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CallOrWriteNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (message_loc.nil? == other.message_loc.nil?) &&
        (read_name === other.read_name) &&
        (write_name === other.write_name) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents assigning to a method call.
  #
  #     foo.bar, = 1
  #     ^^^^^^^
  #
  #     begin
  #     rescue => foo.bar
  #               ^^^^^^^
  #     end
  #
  #     for foo.bar in baz do end
  #         ^^^^^^^
  class CallTargetNode < Node
    # Initialize a new CallTargetNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @name = name
      @message_loc = message_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_call_target_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [receiver]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [receiver, call_operator_loc, message_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc)
      CallTargetNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc }
    end

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     foo.bar = 1
    #     ^^^
    attr_reader :receiver

# Represents the location of the call operator.
    #
    #     foo.bar = 1
    #        ^
    def call_operator_loc
      location = @call_operator_loc
      return location if location.is_a?(Location)
      @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Represents the name of the method being called.
    #
    #     foo.bar = 1 # name `:foo`
    #     ^^^
    attr_reader :name

# Represents the location of the message.
    #
    #     foo.bar = 1
    #         ^^^
    def message_loc
      location = @message_loc
      return location if location.is_a?(Location)
      @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the message_loc location using the given saved source so that
    # it can be retrieved later.
    def save_message_loc(repository)
      repository.enter(node_id, :message_loc)
    end

# def call_operator: () -> String
    def call_operator
      call_operator_loc.slice
    end

# def message: () -> String
    def message
      message_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :call_target_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :call_target_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CallTargetNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (name === other.name) &&
        (message_loc.nil? == other.message_loc.nil?)
    end
  end

# Represents assigning to a local variable in pattern matching.
  #
  #     foo => [bar => baz]
  #            ^^^^^^^^^^^^
  class CapturePatternNode < Node
    # Initialize a new CapturePatternNode node.
    def initialize(source, node_id, location, flags, value, target, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @value = value
      @target = target
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_capture_pattern_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value, target]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value, target]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [value, target, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value, target: self.target, operator_loc: self.operator_loc)
      CapturePatternNode.new(source, node_id, location, flags, value, target, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, value: value, target: target, operator_loc: operator_loc }
    end

# Represents the value to capture.
    #
    #     foo => bar
    #            ^^^
    attr_reader :value

# Represents the target of the capture.
    #
    #     foo => bar
    #     ^^^
    attr_reader :target

# Represents the location of the `=>` operator.
    #
    #     foo => bar
    #         ^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :capture_pattern_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :capture_pattern_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CapturePatternNode) &&
        (value === other.value) &&
        (target === other.target) &&
        (operator_loc.nil? == other.operator_loc.nil?)
    end
  end

# Represents the use of a case statement for pattern matching.
  #
  #     case true
  #     in false
  #     end
  #     ^^^^^^^^^
  class CaseMatchNode < Node
    # Initialize a new CaseMatchNode node.
    def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @predicate = predicate
      @conditions = conditions
      @else_clause = else_clause
      @case_keyword_loc = case_keyword_loc
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_case_match_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [predicate, *conditions, else_clause]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << predicate if predicate
      compact.concat(conditions)
      compact << else_clause if else_clause
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*predicate, *conditions, *else_clause, case_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc)
      CaseMatchNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, predicate: predicate, conditions: conditions, else_clause: else_clause, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc }
    end

# Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     case true; in false; end
    #     ^^^^
    attr_reader :predicate

# Represents the conditions of the case match.
    #
    #     case true; in false; end
    #                ^^^^^^^^
    attr_reader :conditions

# Represents the else clause of the case match.
    #
    #     case true; in false; else; end
    #                          ^^^^
    attr_reader :else_clause

# Represents the location of the `case` keyword.
    #
    #     case true; in false; end
    #     ^^^^
    def case_keyword_loc
      location = @case_keyword_loc
      return location if location.is_a?(Location)
      @case_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the case_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_case_keyword_loc(repository)
      repository.enter(node_id, :case_keyword_loc)
    end

# Represents the location of the `end` keyword.
    #
    #     case true; in false; end
    #                          ^^^
    def end_keyword_loc
      location = @end_keyword_loc
      return location if location.is_a?(Location)
      @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# def case_keyword: () -> String
    def case_keyword
      case_keyword_loc.slice
    end

# def end_keyword: () -> String
    def end_keyword
      end_keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :case_match_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :case_match_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CaseMatchNode) &&
        (predicate === other.predicate) &&
        (conditions.length == other.conditions.length) &&
        conditions.zip(other.conditions).all? { |left, right| left === right } &&
        (else_clause === other.else_clause) &&
        (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents the use of a case statement.
  #
  #     case true
  #     when false
  #     end
  #     ^^^^^^^^^^
  class CaseNode < Node
    # Initialize a new CaseNode node.
    def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @predicate = predicate
      @conditions = conditions
      @else_clause = else_clause
      @case_keyword_loc = case_keyword_loc
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_case_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [predicate, *conditions, else_clause]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*predicate, *conditions, *else_clause, case_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc)
      CaseNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, predicate: predicate, conditions: conditions, else_clause: else_clause, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc }
    end

# Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     case true; when false; end
    #     ^^^^
    attr_reader :predicate

# Represents the conditions of the case statement.
    #
    #     case true; when false; end
    #                ^^^^^^^^^^
    attr_reader :conditions

# Represents the else clause of the case statement.
    #
    #     case true; when false; else; end
    #                            ^^^^
    attr_reader :else_clause

# Represents the location of the `case` keyword.
    #
    #     case true; when false; end
    #     ^^^^
    def case_keyword_loc
      location = @case_keyword_loc
      return location if location.is_a?(Location)
      @case_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Represents the location of the `end` keyword.
    #
    #     case true; when false; end
    #                            ^^^
    def end_keyword_loc
      location = @end_keyword_loc
      return location if location.is_a?(Location)
      @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# def case_keyword: () -> String
    def case_keyword
      case_keyword_loc.slice
    end

# def end_keyword: () -> String
    def end_keyword
      end_keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :case_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :case_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(CaseNode) &&
        (predicate === other.predicate) &&
        (conditions.length == other.conditions.length) &&
        conditions.zip(other.conditions).all? { |left, right| left === right } &&
        (else_clause === other.else_clause) &&
        (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents a class declaration involving the `class` keyword.
  #
  #     class Foo end
  #     ^^^^^^^^^^^^^
  class ClassNode < Node
    # Initialize a new ClassNode node.
    def initialize(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @locals = locals
      @class_keyword_loc = class_keyword_loc
      @constant_path = constant_path
      @inheritance_operator_loc = inheritance_operator_loc
      @superclass = superclass
      @body = body
      @end_keyword_loc = end_keyword_loc
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [constant_path, superclass, body]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << constant_path
      compact << superclass if superclass
      compact << body if body
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [class_keyword_loc, constant_path, *inheritance_operator_loc, *superclass, *body, end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, class_keyword_loc: self.class_keyword_loc, constant_path: self.constant_path, inheritance_operator_loc: self.inheritance_operator_loc, superclass: self.superclass, body: self.body, end_keyword_loc: self.end_keyword_loc, name: self.name)
      ClassNode.new(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, locals: locals, class_keyword_loc: class_keyword_loc, constant_path: constant_path, inheritance_operator_loc: inheritance_operator_loc, superclass: superclass, body: body, end_keyword_loc: end_keyword_loc, name: name }
    end

# attr_reader locals: Array[Symbol]
    attr_reader :locals

# attr_reader class_keyword_loc: Location
    def class_keyword_loc
      location = @class_keyword_loc
      return location if location.is_a?(Location)
      @class_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the class_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_class_keyword_loc(repository)
      repository.enter(node_id, :class_keyword_loc)
    end

# attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode
    attr_reader :constant_path

# attr_reader inheritance_operator_loc: Location?
    def inheritance_operator_loc
      location = @inheritance_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @inheritance_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the inheritance_operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_inheritance_operator_loc(repository)
      repository.enter(node_id, :inheritance_operator_loc) unless @inheritance_operator_loc.nil?
    end

# attr_reader superclass: Prism::node?
    attr_reader :superclass

# attr_reader body: StatementsNode | BeginNode | nil
    attr_reader :body

# attr_reader end_keyword_loc: Location
    def end_keyword_loc
      location = @end_keyword_loc
      return location if location.is_a?(Location)
      @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# attr_reader name: Symbol
    attr_reader :name

# def class_keyword: () -> String
    def class_keyword
      class_keyword_loc.slice
    end

# def inheritance_operator: () -> String?
    def inheritance_operator
      inheritance_operator_loc&.slice
    end

# def end_keyword: () -> String
    def end_keyword
      end_keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ClassNode) &&
        (locals.length == other.locals.length) &&
        locals.zip(other.locals).all? { |left, right| left === right } &&
        (class_keyword_loc.nil? == other.class_keyword_loc.nil?) &&
        (constant_path === other.constant_path) &&
        (inheritance_operator_loc.nil? == other.inheritance_operator_loc.nil?) &&
        (superclass === other.superclass) &&
        (body === other.body) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?) &&
        (name === other.name)
    end
  end

# Represents the use of the `&&=` operator for assignment to a class variable.
  #
  #     @@target &&= value
  #     ^^^^^^^^^^^^^^^^^^
  class ClassVariableAndWriteNode < Node
    # Initialize a new ClassVariableAndWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      ClassVariableAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name, name_loc: name_loc, operator_loc: operator_loc, value: value }
    end

# The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
    #
    #     @@target &&= value # name `:@@target`
    #     ^^^^^^^^
    attr_reader :name

# Represents the location of the variable name.
    #
    #     @@target &&= value
    #     ^^^^^^^^
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# Represents the location of the `&&=` operator.
    #
    #     @@target &&= value
    #              ^^^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     @@target &&= value
    #                  ^^^^^
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_and_write_node
    end

# Represents assigning to a class variable using an operator that isn't `=`.
  #
  #     @@target += value
  #     ^^^^^^^^^^^^^^^^^
  class ClassVariableOperatorWriteNode < Node
    # Initialize a new ClassVariableOperatorWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @binary_operator_loc = binary_operator_loc
      @value = value
      @binary_operator = binary_operator
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator)
      ClassVariableOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name, name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator }
    end

# attr_reader name: Symbol
    attr_reader :name

# attr_reader name_loc: Location
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# attr_reader binary_operator_loc: Location
    def binary_operator_loc
      location = @binary_operator_loc
      return location if location.is_a?(Location)
      @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# attr_reader value: Prism::node
    attr_reader :value

# attr_reader binary_operator: Symbol
    attr_reader :binary_operator

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_operator_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_operator_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ClassVariableOperatorWriteNode) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
        (value === other.value) &&
        (binary_operator === other.binary_operator)
    end
  end

# Represents the use of the `||=` operator for assignment to a class variable.
  #
  #     @@target ||= value
  #     ^^^^^^^^^^^^^^^^^^
  class ClassVariableOrWriteNode < Node
    # Initialize a new ClassVariableOrWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_or_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      ClassVariableOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# attr_reader operator_loc: Location
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_or_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_or_write_node
    end

# Represents referencing a class variable.
  #
  #     @@foo
  #     ^^^^^
  class ClassVariableReadNode < Node
    # Initialize a new ClassVariableReadNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_read_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      ClassVariableReadNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
    #
    #     @@abc   # name `:@@abc`
    #
    #     @@_test # name `:@@_test`
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_read_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_read_node
    end

# Represents writing to a class variable in a context that doesn't have an explicit value.
  #
  #     @@foo, @@bar = baz
  #     ^^^^^  ^^^^^
  class ClassVariableTargetNode < Node
    # Initialize a new ClassVariableTargetNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_target_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      ClassVariableTargetNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_target_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_target_node
    end

# Represents writing to a class variable.
  #
  #     @@foo = 1
  #     ^^^^^^^^^
  class ClassVariableWriteNode < Node
    # Initialize a new ClassVariableWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @value = value
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_class_variable_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, value, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, value: self.value, operator_loc: self.operator_loc)
      ClassVariableWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name, name_loc: name_loc, value: value, operator_loc: operator_loc }
    end

# The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
    #
    #     @@abc = 123     # name `@@abc`
    #
    #     @@_test = :test # name `@@_test`
    attr_reader :name

# The location of the variable name.
    #
    #     @@foo = :bar
    #     ^^^^^
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     @@foo = :bar
    #             ^^^^
    #
    #     @@_xyz = 123
    #              ^^^
    attr_reader :value

# The location of the `=` operator.
    #
    #     @@foo = :bar
    #           ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :class_variable_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :class_variable_write_node
    end

# Represents the use of the `&&=` operator for assignment to a constant.
  #
  #     Target &&= value
  #     ^^^^^^^^^^^^^^^^
  class ConstantAndWriteNode < Node
    # Initialize a new ConstantAndWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      ConstantAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_and_write_node
    end

# Represents assigning to a constant using an operator that isn't `=`.
  #
  #     Target += value
  #     ^^^^^^^^^^^^^^^
  class ConstantOperatorWriteNode < Node
    # Initialize a new ConstantOperatorWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @binary_operator_loc = binary_operator_loc
      @value = value
      @binary_operator = binary_operator
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator)
      ConstantOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# attr_reader binary_operator: Symbol
    attr_reader :binary_operator

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_operator_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_operator_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantOperatorWriteNode) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
        (value === other.value) &&
        (binary_operator === other.binary_operator)
    end
  end

# Represents the use of the `||=` operator for assignment to a constant.
  #
  #     Target ||= value
  #     ^^^^^^^^^^^^^^^^
  class ConstantOrWriteNode < Node
    # Initialize a new ConstantOrWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_or_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      ConstantOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_or_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_or_write_node
    end

# Represents the use of the `&&=` operator for assignment to a constant path.
  #
  #     Parent::Child &&= value
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathAndWriteNode < Node
    # Initialize a new ConstantPathAndWriteNode node.
    def initialize(source, node_id, location, flags, target, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @target = target
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [target, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [target, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [target, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, target: self.target, operator_loc: self.operator_loc, value: self.value)
      ConstantPathAndWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, target: target, operator_loc: operator_loc, value: value }
    end

# attr_reader target: ConstantPathNode
    attr_reader :target

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_and_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathAndWriteNode) &&
        (target === other.target) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents accessing a constant through a path of `::` operators.
  #
  #     Foo::Bar
  #     ^^^^^^^^
  class ConstantPathNode < Node
    # Initialize a new ConstantPathNode node.
    def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @parent = parent
      @name = name
      @delimiter_loc = delimiter_loc
      @name_loc = name_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [parent]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << parent if parent
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*parent, delimiter_loc, name_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, parent: self.parent, name: self.name, delimiter_loc: self.delimiter_loc, name_loc: self.name_loc)
      ConstantPathNode.new(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, parent: parent, name: name, delimiter_loc: delimiter_loc, name_loc: name_loc }
    end

# The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
    #
    #     Foo::Bar
    #     ^^^
    #
    #     self::Test
    #     ^^^^
    #
    #     a.b::C
    #     ^^^
    attr_reader :parent

# The name of the constant being accessed. This could be `nil` in the event of a syntax error.
    attr_reader :name

# The location of the `::` delimiter.
    #
    #     ::Foo
    #     ^^
    #
    #     One::Two
    #        ^^
    def delimiter_loc
      location = @delimiter_loc
      return location if location.is_a?(Location)
      @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the delimiter_loc location using the given saved source so that
    # it can be retrieved later.
    def save_delimiter_loc(repository)
      repository.enter(node_id, :delimiter_loc)
    end

# The location of the name of the constant.
    #
    #     ::Foo
    #       ^^^
    #
    #     One::Two
    #          ^^^
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# def delimiter: () -> String
    def delimiter
      delimiter_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathNode) &&
        (parent === other.parent) &&
        (name === other.name) &&
        (delimiter_loc.nil? == other.delimiter_loc.nil?) &&
        (name_loc.nil? == other.name_loc.nil?)
    end
  end

# Represents assigning to a constant path using an operator that isn't `=`.
  #
  #     Parent::Child += value
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathOperatorWriteNode < Node
    # Initialize a new ConstantPathOperatorWriteNode node.
    def initialize(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @target = target
      @binary_operator_loc = binary_operator_loc
      @value = value
      @binary_operator = binary_operator
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [target, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [target, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [target, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, target: self.target, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator)
      ConstantPathOperatorWriteNode.new(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, target: target, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator }
    end

# attr_reader target: ConstantPathNode
    attr_reader :target

# attr_reader value: Prism::node
    attr_reader :value

# attr_reader binary_operator: Symbol
    attr_reader :binary_operator

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_operator_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_operator_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathOperatorWriteNode) &&
        (target === other.target) &&
        (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
        (value === other.value) &&
        (binary_operator === other.binary_operator)
    end
  end

# Represents the use of the `||=` operator for assignment to a constant path.
  #
  #     Parent::Child ||= value
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathOrWriteNode < Node
    # Initialize a new ConstantPathOrWriteNode node.
    def initialize(source, node_id, location, flags, target, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @target = target
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_or_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [target, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [target, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [target, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, target: self.target, operator_loc: self.operator_loc, value: self.value)
      ConstantPathOrWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader target: ConstantPathNode
    attr_reader :target

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_or_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_or_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathOrWriteNode) &&
        (target === other.target) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents writing to a constant path in a context that doesn't have an explicit value.
  #
  #     Foo::Foo, Bar::Bar = baz
  #     ^^^^^^^^  ^^^^^^^^
  class ConstantPathTargetNode < Node
    # Initialize a new ConstantPathTargetNode node.
    def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @parent = parent
      @name = name
      @delimiter_loc = delimiter_loc
      @name_loc = name_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_target_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [parent]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << parent if parent
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*parent, delimiter_loc, name_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, parent: self.parent, name: self.name, delimiter_loc: self.delimiter_loc, name_loc: self.name_loc)
      ConstantPathTargetNode.new(source, node_id, location, flags, parent, name, delimiter_loc, name_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader parent: Prism::node?
    attr_reader :parent

# attr_reader name: Symbol?
    attr_reader :name

# attr_reader delimiter_loc: Location
    def delimiter_loc
      location = @delimiter_loc
      return location if location.is_a?(Location)
      @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the delimiter_loc location using the given saved source so that
    # it can be retrieved later.
    def save_delimiter_loc(repository)
      repository.enter(node_id, :delimiter_loc)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# def delimiter: () -> String
    def delimiter
      delimiter_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_target_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_target_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathTargetNode) &&
        (parent === other.parent) &&
        (name === other.name) &&
        (delimiter_loc.nil? == other.delimiter_loc.nil?) &&
        (name_loc.nil? == other.name_loc.nil?)
    end
  end

# Represents writing to a constant path.
  #
  #     ::Foo = 1
  #     ^^^^^^^^^
  #
  #     Foo::Bar = 1
  #     ^^^^^^^^^^^^
  #
  #     ::Foo::Bar = 1
  #     ^^^^^^^^^^^^^^
  class ConstantPathWriteNode < Node
    # Initialize a new ConstantPathWriteNode node.
    def initialize(source, node_id, location, flags, target, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @target = target
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_path_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [target, value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [target, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [target, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, target: self.target, operator_loc: self.operator_loc, value: self.value)
      ConstantPathWriteNode.new(source, node_id, location, flags, target, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# A node representing the constant path being written to.
    #
    #     Foo::Bar = 1
    #     ^^^^^^^^
    #
    #     ::Foo = :abc
    #     ^^^^^
    attr_reader :target

# The location of the `=` operator.
    #
    #     ::ABC = 123
    #           ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     FOO::BAR = :abc
    #                ^^^^
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_path_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_path_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ConstantPathWriteNode) &&
        (target === other.target) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents referencing a constant.
  #
  #     Foo
  #     ^^^
  class ConstantReadNode < Node
    # Initialize a new ConstantReadNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_read_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      ConstantReadNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
    #
    #     X              # name `:X`
    #
    #     SOME_CONSTANT  # name `:SOME_CONSTANT`
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_read_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_read_node
    end

# Represents writing to a constant in a context that doesn't have an explicit value.
  #
  #     Foo, Bar = baz
  #     ^^^  ^^^
  class ConstantTargetNode < Node
    # Initialize a new ConstantTargetNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_target_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      ConstantTargetNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_target_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_target_node
    end

# Represents writing to a constant.
  #
  #     Foo = 1
  #     ^^^^^^^
  class ConstantWriteNode < Node
    # Initialize a new ConstantWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @value = value
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_constant_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, value, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, value: self.value, operator_loc: self.operator_loc)
      ConstantWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
    #
    #     Foo = :bar # name `:Foo`
    #
    #     XYZ = 1    # name `:XYZ`
    attr_reader :name

# The location of the constant name.
    #
    #     FOO = 1
    #     ^^^
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     FOO = :bar
    #           ^^^^
    #
    #     MyClass = Class.new
    #               ^^^^^^^^^
    attr_reader :value

# The location of the `=` operator.
    #
    #     FOO = :bar
    #         ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :constant_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :constant_write_node
    end

# Represents a method definition.
  #
  #     def method
  #     end
  #     ^^^^^^^^^^
  class DefNode < Node
    # Initialize a new DefNode node.
    def initialize(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @receiver = receiver
      @parameters = parameters
      @body = body
      @locals = locals
      @def_keyword_loc = def_keyword_loc
      @operator_loc = operator_loc
      @lparen_loc = lparen_loc
      @rparen_loc = rparen_loc
      @equal_loc = equal_loc
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_def_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, parameters, body]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << receiver if receiver
      compact << parameters if parameters
      compact << body if body
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, *receiver, *parameters, *body, def_keyword_loc, *operator_loc, *lparen_loc, *rparen_loc, *equal_loc, *end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, receiver: self.receiver, parameters: self.parameters, body: self.body, locals: self.locals, def_keyword_loc: self.def_keyword_loc, operator_loc: self.operator_loc, lparen_loc: self.lparen_loc, rparen_loc: self.rparen_loc, equal_loc: self.equal_loc, end_keyword_loc: self.end_keyword_loc)
      DefNode.new(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, name: name, name_loc: name_loc, receiver: receiver, parameters: parameters, body: body, locals: locals, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc }
    end

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# attr_reader receiver: Prism::node?
    attr_reader :receiver

# attr_reader parameters: ParametersNode?
    attr_reader :parameters

# attr_reader body: StatementsNode | BeginNode | nil
    attr_reader :body

# attr_reader locals: Array[Symbol]
    attr_reader :locals

# attr_reader def_keyword_loc: Location
    def def_keyword_loc
      location = @def_keyword_loc
      return location if location.is_a?(Location)
      @def_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the def_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_def_keyword_loc(repository)
      repository.enter(node_id, :def_keyword_loc)
    end

# attr_reader operator_loc: Location?
    def operator_loc
      location = @operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# attr_reader lparen_loc: Location?
    def lparen_loc
      location = @lparen_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @lparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the lparen_loc location using the given saved source so that
    # it can be retrieved later.
    def save_lparen_loc(repository)
      repository.enter(node_id, :lparen_loc) unless @lparen_loc.nil?
    end

# attr_reader rparen_loc: Location?
    def rparen_loc
      location = @rparen_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @rparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the rparen_loc location using the given saved source so that
    # it can be retrieved later.
    def save_rparen_loc(repository)
      repository.enter(node_id, :rparen_loc) unless @rparen_loc.nil?
    end

# attr_reader equal_loc: Location?
    def equal_loc
      location = @equal_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @equal_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the equal_loc location using the given saved source so that
    # it can be retrieved later.
    def save_equal_loc(repository)
      repository.enter(node_id, :equal_loc) unless @equal_loc.nil?
    end

# attr_reader end_keyword_loc: Location?
    def end_keyword_loc
      location = @end_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# def def_keyword: () -> String
    def def_keyword
      def_keyword_loc.slice
    end

# def operator: () -> String?
    def operator
      operator_loc&.slice
    end

# def lparen: () -> String?
    def lparen
      lparen_loc&.slice
    end

# def rparen: () -> String?
    def rparen
      rparen_loc&.slice
    end

# def equal: () -> String?
    def equal
      equal_loc&.slice
    end

# def end_keyword: () -> String?
    def end_keyword
      end_keyword_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :def_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :def_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(DefNode) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (receiver === other.receiver) &&
        (parameters === other.parameters) &&
        (body === other.body) &&
        (locals.length == other.locals.length) &&
        locals.zip(other.locals).all? { |left, right| left === right } &&
        (def_keyword_loc.nil? == other.def_keyword_loc.nil?) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (lparen_loc.nil? == other.lparen_loc.nil?) &&
        (rparen_loc.nil? == other.rparen_loc.nil?) &&
        (equal_loc.nil? == other.equal_loc.nil?) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents the use of the `defined?` keyword.
  #
  #     defined?(a)
  #     ^^^^^^^^^^^
  class DefinedNode < Node
    # Initialize a new DefinedNode node.
    def initialize(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @lparen_loc = lparen_loc
      @value = value
      @rparen_loc = rparen_loc
      @keyword_loc = keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_defined_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*lparen_loc, value, *rparen_loc, keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, lparen_loc: self.lparen_loc, value: self.value, rparen_loc: self.rparen_loc, keyword_loc: self.keyword_loc)
      DefinedNode.new(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, lparen_loc: lparen_loc, value: value, rparen_loc: rparen_loc, keyword_loc: keyword_loc }
    end

# attr_reader value: Prism::node
    attr_reader :value

# attr_reader keyword_loc: Location
    def keyword_loc
      location = @keyword_loc
      return location if location.is_a?(Location)
      @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_keyword_loc(repository)
      repository.enter(node_id, :keyword_loc)
    end

# def lparen: () -> String?
    def lparen
      lparen_loc&.slice
    end

# def rparen: () -> String?
    def rparen
      rparen_loc&.slice
    end

# def keyword: () -> String
    def keyword
      keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :defined_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :defined_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(DefinedNode) &&
        (lparen_loc.nil? == other.lparen_loc.nil?) &&
        (value === other.value) &&
        (rparen_loc.nil? == other.rparen_loc.nil?) &&
        (keyword_loc.nil? == other.keyword_loc.nil?)
    end
  end

# Represents an `else` clause in a `case`, `if`, or `unless` statement.
  #
  #     if a then b else c end
  #                 ^^^^^^^^^^
  class ElseNode < Node
    # Initialize a new ElseNode node.
    def initialize(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @else_keyword_loc = else_keyword_loc
      @statements = statements
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_else_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [statements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << statements if statements
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [else_keyword_loc, *statements, *end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, else_keyword_loc: self.else_keyword_loc, statements: self.statements, end_keyword_loc: self.end_keyword_loc)
      ElseNode.new(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, else_keyword_loc: else_keyword_loc, statements: statements, end_keyword_loc: end_keyword_loc }
    end

# attr_reader else_keyword_loc: Location
    def else_keyword_loc
      location = @else_keyword_loc
      return location if location.is_a?(Location)
      @else_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the else_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_else_keyword_loc(repository)
      repository.enter(node_id, :else_keyword_loc)
    end

# attr_reader statements: StatementsNode?
    attr_reader :statements

# def else_keyword: () -> String
    def else_keyword
      else_keyword_loc.slice
    end

# def end_keyword: () -> String?
    def end_keyword
      end_keyword_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :else_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :else_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ElseNode) &&
        (else_keyword_loc.nil? == other.else_keyword_loc.nil?) &&
        (statements === other.statements) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents an interpolated set of statements.
  #
  #     "foo #{bar}"
  #          ^^^^^^
  class EmbeddedStatementsNode < Node
    # Initialize a new EmbeddedStatementsNode node.
    def initialize(source, node_id, location, flags, opening_loc, statements, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @opening_loc = opening_loc
      @statements = statements
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_embedded_statements_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [statements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << statements if statements
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [opening_loc, *statements, closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, statements: self.statements, closing_loc: self.closing_loc)
      EmbeddedStatementsNode.new(source, node_id, location, flags, opening_loc, statements, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, opening_loc: opening_loc, statements: statements, closing_loc: closing_loc }
    end

# attr_reader opening_loc: Location
    def opening_loc
      location = @opening_loc
      return location if location.is_a?(Location)
      @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the opening_loc location using the given saved source so that
    # it can be retrieved later.
    def save_opening_loc(repository)
      repository.enter(node_id, :opening_loc)
    end

# attr_reader statements: StatementsNode?
    attr_reader :statements

# attr_reader closing_loc: Location
    def closing_loc
      location = @closing_loc
      return location if location.is_a?(Location)
      @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the closing_loc location using the given saved source so that
    # it can be retrieved later.
    def save_closing_loc(repository)
      repository.enter(node_id, :closing_loc)
    end

# def opening: () -> String
    def opening
      opening_loc.slice
    end

# def closing: () -> String
    def closing
      closing_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :embedded_statements_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :embedded_statements_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(EmbeddedStatementsNode) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (statements === other.statements) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents an interpolated variable.
  #
  #     "foo #@bar"
  #          ^^^^^
  class EmbeddedVariableNode < Node
    # Initialize a new EmbeddedVariableNode node.
    def initialize(source, node_id, location, flags, operator_loc, variable)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @operator_loc = operator_loc
      @variable = variable
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_embedded_variable_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [variable]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [variable]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [operator_loc, variable] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, operator_loc: self.operator_loc, variable: self.variable)
      EmbeddedVariableNode.new(source, node_id, location, flags, operator_loc, variable)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, operator_loc: operator_loc, variable: variable }
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode
    attr_reader :variable

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :embedded_variable_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :embedded_variable_node
    end

# Represents an `ensure` clause in a `begin` statement.
  #
  #     begin
  #       foo
  #     ensure
  #     ^^^^^^
  #       bar
  #     end
  class EnsureNode < Node
    # Initialize a new EnsureNode node.
    def initialize(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @ensure_keyword_loc = ensure_keyword_loc
      @statements = statements
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_ensure_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [statements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << statements if statements
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [ensure_keyword_loc, *statements, end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, ensure_keyword_loc: self.ensure_keyword_loc, statements: self.statements, end_keyword_loc: self.end_keyword_loc)
      EnsureNode.new(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, ensure_keyword_loc: ensure_keyword_loc, statements: statements, end_keyword_loc: end_keyword_loc }
    end

# attr_reader ensure_keyword_loc: Location
    def ensure_keyword_loc
      location = @ensure_keyword_loc
      return location if location.is_a?(Location)
      @ensure_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the ensure_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_ensure_keyword_loc(repository)
      repository.enter(node_id, :ensure_keyword_loc)
    end

# attr_reader statements: StatementsNode?
    attr_reader :statements

# def ensure_keyword: () -> String
    def ensure_keyword
      ensure_keyword_loc.slice
    end

# def end_keyword: () -> String
    def end_keyword
      end_keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :ensure_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :ensure_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(EnsureNode) &&
        (ensure_keyword_loc.nil? == other.ensure_keyword_loc.nil?) &&
        (statements === other.statements) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents the use of the literal `false` keyword.
  #
  #     false
  #     ^^^^^
  class FalseNode < Node
    # Initialize a new FalseNode node.
    def initialize(source, node_id, location, flags)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_false_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags)
      FalseNode.new(source, node_id, location, flags)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location }
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :false_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :false_node
    end

# Represents a find pattern in pattern matching.
  #
  #     foo in *bar, baz, *qux
  #            ^^^^^^^^^^^^^^^
  #
  #     foo in [*bar, baz, *qux]
  #            ^^^^^^^^^^^^^^^^^
  #
  #     foo in Foo(*bar, baz, *qux)
  #            ^^^^^^^^^^^^^^^^^^^^
  class FindPatternNode < Node
    # Initialize a new FindPatternNode node.
    def initialize(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @constant = constant
      @left = left
      @requireds = requireds
      @right = right
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_find_pattern_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [constant, left, *requireds, right]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << constant if constant
      compact << left
      compact.concat(requireds)
      compact << right
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*constant, left, *requireds, right, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, left: self.left, requireds: self.requireds, right: self.right, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      FindPatternNode.new(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, constant: constant, left: left, requireds: requireds, right: right, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# attr_reader constant: ConstantReadNode | ConstantPathNode | nil
    attr_reader :constant

# attr_reader left: SplatNode
    attr_reader :left

# attr_reader requireds: Array[Prism::node]
    attr_reader :requireds

# attr_reader right: SplatNode | MissingNode
    attr_reader :right

# attr_reader opening_loc: Location?
    def opening_loc
      location = @opening_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# attr_reader closing_loc: Location?
    def closing_loc
      location = @closing_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :find_pattern_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :find_pattern_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(FindPatternNode) &&
        (constant === other.constant) &&
        (left === other.left) &&
        (requireds.length == other.requireds.length) &&
        requireds.zip(other.requireds).all? { |left, right| left === right } &&
        (right === other.right) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents the use of the `..` or `...` operators to create flip flops.
  #
  #     baz if foo .. bar
  #            ^^^^^^^^^^
  class FlipFlopNode < Node
    # Initialize a new FlipFlopNode node.
    def initialize(source, node_id, location, flags, left, right, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @left = left
      @right = right
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_flip_flop_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [left, right]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << left if left
      compact << right if right
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*left, *right, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, left: self.left, right: self.right, operator_loc: self.operator_loc)
      FlipFlopNode.new(source, node_id, location, flags, left, right, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, left: left, right: right, operator_loc: operator_loc }
    end

# def exclude_end?: () -> bool
    def exclude_end?
      flags.anybits?(RangeFlags::EXCLUDE_END)
    end

# attr_reader left: Prism::node?
    attr_reader :left

# attr_reader right: Prism::node?
    attr_reader :right

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :flip_flop_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :flip_flop_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(FlipFlopNode) &&
        (flags === other.flags) &&
        (left === other.left) &&
        (right === other.right) &&
        (operator_loc.nil? == other.operator_loc.nil?)
    end
  end

# Represents a floating point number literal.
  #
  #     1.0
  #     ^^^
  class FloatNode < Node
    # Initialize a new FloatNode node.
    def initialize(source, node_id, location, flags, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_float_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value)
      FloatNode.new(source, node_id, location, flags, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, value: value }
    end

# The value of the floating point number as a Float.
    attr_reader :value

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :float_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :float_node
    end

# Represents the use of the `for` keyword.
  #
  #     for i in a end
  #     ^^^^^^^^^^^^^^
  class ForNode < Node
    # Initialize a new ForNode node.
    def initialize(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @index = index
      @collection = collection
      @statements = statements
      @for_keyword_loc = for_keyword_loc
      @in_keyword_loc = in_keyword_loc
      @do_keyword_loc = do_keyword_loc
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_for_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [index, collection, statements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << index
      compact << collection
      compact << statements if statements
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [index, collection, *statements, for_keyword_loc, in_keyword_loc, *do_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, index: self.index, collection: self.collection, statements: self.statements, for_keyword_loc: self.for_keyword_loc, in_keyword_loc: self.in_keyword_loc, do_keyword_loc: self.do_keyword_loc, end_keyword_loc: self.end_keyword_loc)
      ForNode.new(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, index: index, collection: collection, statements: statements, for_keyword_loc: for_keyword_loc, in_keyword_loc: in_keyword_loc, do_keyword_loc: do_keyword_loc, end_keyword_loc: end_keyword_loc }
    end

# The index expression for `for` loops.
    #
    #     for i in a end
    #         ^
    attr_reader :index

# The collection to iterate over.
    #
    #     for i in a end
    #              ^
    attr_reader :collection

# Represents the body of statements to execute for each iteration of the loop.
    #
    #     for i in a
    #       foo(i)
    #       ^^^^^^
    #     end
    attr_reader :statements

# The location of the `for` keyword.
    #
    #     for i in a end
    #     ^^^
    def for_keyword_loc
      location = @for_keyword_loc
      return location if location.is_a?(Location)
      @for_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the for_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_for_keyword_loc(repository)
      repository.enter(node_id, :for_keyword_loc)
    end

# The location of the `in` keyword.
    #
    #     for i in a end
    #           ^^
    def in_keyword_loc
      location = @in_keyword_loc
      return location if location.is_a?(Location)
      @in_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the in_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_in_keyword_loc(repository)
      repository.enter(node_id, :in_keyword_loc)
    end

# The location of the `do` keyword, if present.
    #
    #     for i in a do end
    #                ^^
    def do_keyword_loc
      location = @do_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @do_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the do_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_do_keyword_loc(repository)
      repository.enter(node_id, :do_keyword_loc) unless @do_keyword_loc.nil?
    end

# The location of the `end` keyword.
    #
    #     for i in a end
    #                ^^^
    def end_keyword_loc
      location = @end_keyword_loc
      return location if location.is_a?(Location)
      @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# def for_keyword: () -> String
    def for_keyword
      for_keyword_loc.slice
    end

# def in_keyword: () -> String
    def in_keyword
      in_keyword_loc.slice
    end

# def do_keyword: () -> String?
    def do_keyword
      do_keyword_loc&.slice
    end

# def end_keyword: () -> String
    def end_keyword
      end_keyword_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :for_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :for_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(ForNode) &&
        (index === other.index) &&
        (collection === other.collection) &&
        (statements === other.statements) &&
        (for_keyword_loc.nil? == other.for_keyword_loc.nil?) &&
        (in_keyword_loc.nil? == other.in_keyword_loc.nil?) &&
        (do_keyword_loc.nil? == other.do_keyword_loc.nil?) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents forwarding all arguments to this method to another method.
  #
  #     def foo(...)
  #       bar(...)
  #           ^^^
  #     end
  class ForwardingArgumentsNode < Node
    # Initialize a new ForwardingArgumentsNode node.
    def initialize(source, node_id, location, flags)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_forwarding_arguments_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags)
      ForwardingArgumentsNode.new(source, node_id, location, flags)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location }
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :forwarding_arguments_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :forwarding_arguments_node
    end

# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
  #
  #     def foo(...)
  #             ^^^
  #     end
  class ForwardingParameterNode < Node
    # Initialize a new ForwardingParameterNode node.
    def initialize(source, node_id, location, flags)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_forwarding_parameter_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags)
      ForwardingParameterNode.new(source, node_id, location, flags)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location }
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :forwarding_parameter_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :forwarding_parameter_node
    end

# Represents the use of the `super` keyword without parentheses or arguments.
  #
  #     super
  #     ^^^^^
  class ForwardingSuperNode < Node
    # Initialize a new ForwardingSuperNode node.
    def initialize(source, node_id, location, flags, block)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @block = block
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_forwarding_super_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [block]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << block if block
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*block] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, block: self.block)
      ForwardingSuperNode.new(source, node_id, location, flags, block)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, block: block }
    end

# attr_reader block: BlockNode?
    attr_reader :block

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :forwarding_super_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :forwarding_super_node
    end

# Represents the use of the `&&=` operator for assignment to a global variable.
  #
  #     $target &&= value
  #     ^^^^^^^^^^^^^^^^^
  class GlobalVariableAndWriteNode < Node
    # Initialize a new GlobalVariableAndWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      GlobalVariableAndWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_and_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(GlobalVariableAndWriteNode) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents assigning to a global variable using an operator that isn't `=`.
  #
  #     $target += value
  #     ^^^^^^^^^^^^^^^^
  class GlobalVariableOperatorWriteNode < Node
    # Initialize a new GlobalVariableOperatorWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @binary_operator_loc = binary_operator_loc
      @value = value
      @binary_operator = binary_operator
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator)
      GlobalVariableOperatorWriteNode.new(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# attr_reader binary_operator: Symbol
    attr_reader :binary_operator

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_operator_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_operator_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(GlobalVariableOperatorWriteNode) &&
        (name === other.name) &&
        (name_loc.nil? == other.name_loc.nil?) &&
        (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
        (value === other.value) &&
        (binary_operator === other.binary_operator)
    end
  end

# Represents the use of the `||=` operator for assignment to a global variable.
  #
  #     $target ||= value
  #     ^^^^^^^^^^^^^^^^^
  class GlobalVariableOrWriteNode < Node
    # Initialize a new GlobalVariableOrWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_or_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value)
      GlobalVariableOrWriteNode.new(source, node_id, location, flags, name, name_loc, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_or_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_or_write_node
    end

# Represents referencing a global variable.
  #
  #     $foo
  #     ^^^^
  class GlobalVariableReadNode < Node
    # Initialize a new GlobalVariableReadNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_read_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      GlobalVariableReadNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
    #
    #     $foo   # name `:$foo`
    #
    #     $_Test # name `:$_Test`
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_read_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_read_node
    end

# Represents writing to a global variable in a context that doesn't have an explicit value.
  #
  #     $foo, $bar = baz
  #     ^^^^  ^^^^
  class GlobalVariableTargetNode < Node
    # Initialize a new GlobalVariableTargetNode node.
    def initialize(source, node_id, location, flags, name)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_target_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name)
      GlobalVariableTargetNode.new(source, node_id, location, flags, name)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# attr_reader name: Symbol
    attr_reader :name

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_target_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_target_node
    end

# Represents writing to a global variable.
  #
  #     $foo = 1
  #     ^^^^^^^^
  class GlobalVariableWriteNode < Node
    # Initialize a new GlobalVariableWriteNode node.
    def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @name = name
      @name_loc = name_loc
      @value = value
      @operator_loc = operator_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_global_variable_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [name_loc, value, operator_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, value: self.value, operator_loc: self.operator_loc)
      GlobalVariableWriteNode.new(source, node_id, location, flags, name, name_loc, value, operator_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
    #
    #     $foo = :bar  # name `:$foo`
    #
    #     $_Test = 123 # name `:$_Test`
    attr_reader :name

# The location of the global variable's name.
    #
    #     $foo = :bar
    #     ^^^^
    def name_loc
      location = @name_loc
      return location if location.is_a?(Location)
      @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the name_loc location using the given saved source so that
    # it can be retrieved later.
    def save_name_loc(repository)
      repository.enter(node_id, :name_loc)
    end

# The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
    #
    #     $foo = :bar
    #            ^^^^
    #
    #     $-xyz = 123
    #             ^^^
    attr_reader :value

# The location of the `=` operator.
    #
    #     $foo = :bar
    #          ^
    def operator_loc
      location = @operator_loc
      return location if location.is_a?(Location)
      @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :global_variable_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :global_variable_write_node
    end

# Represents a hash literal.
  #
  #     { a => b }
  #     ^^^^^^^^^^
  class HashNode < Node
    # Initialize a new HashNode node.
    def initialize(source, node_id, location, flags, opening_loc, elements, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @opening_loc = opening_loc
      @elements = elements
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_hash_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [*elements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [*elements]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [opening_loc, *elements, closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, elements: self.elements, closing_loc: self.closing_loc)
      HashNode.new(source, node_id, location, flags, opening_loc, elements, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, opening_loc: opening_loc, elements: elements, closing_loc: closing_loc }
    end

# The location of the opening brace.
    #
    #     { a => b }
    #     ^
    def opening_loc
      location = @opening_loc
      return location if location.is_a?(Location)
      @opening_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the opening_loc location using the given saved source so that
    # it can be retrieved later.
    def save_opening_loc(repository)
      repository.enter(node_id, :opening_loc)
    end

# The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
    #
    #     { a: b }
    #       ^^^^
    #
    #     { **foo }
    #       ^^^^^
    attr_reader :elements

# The location of the closing brace.
    #
    #     { a => b }
    #              ^
    def closing_loc
      location = @closing_loc
      return location if location.is_a?(Location)
      @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the closing_loc location using the given saved source so that
    # it can be retrieved later.
    def save_closing_loc(repository)
      repository.enter(node_id, :closing_loc)
    end

# def opening: () -> String
    def opening
      opening_loc.slice
    end

# def closing: () -> String
    def closing
      closing_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :hash_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :hash_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(HashNode) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (elements.length == other.elements.length) &&
        elements.zip(other.elements).all? { |left, right| left === right } &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents a hash pattern in pattern matching.
  #
  #     foo => { a: 1, b: 2 }
  #            ^^^^^^^^^^^^^^
  #
  #     foo => { a: 1, b: 2, **c }
  #            ^^^^^^^^^^^^^^^^^^^
  class HashPatternNode < Node
    # Initialize a new HashPatternNode node.
    def initialize(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @constant = constant
      @elements = elements
      @rest = rest
      @opening_loc = opening_loc
      @closing_loc = closing_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_hash_pattern_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [constant, *elements, rest]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << constant if constant
      compact.concat(elements)
      compact << rest if rest
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*constant, *elements, *rest, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, elements: self.elements, rest: self.rest, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
      HashPatternNode.new(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, constant: constant, elements: elements, rest: rest, opening_loc: opening_loc, closing_loc: closing_loc }
    end

# attr_reader constant: ConstantReadNode | ConstantPathNode | nil
    attr_reader :constant

# attr_reader elements: Array[AssocNode]
    attr_reader :elements

# attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
    attr_reader :rest

# def opening: () -> String?
    def opening
      opening_loc&.slice
    end

# def closing: () -> String?
    def closing
      closing_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :hash_pattern_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :hash_pattern_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(HashPatternNode) &&
        (constant === other.constant) &&
        (elements.length == other.elements.length) &&
        elements.zip(other.elements).all? { |left, right| left === right } &&
        (rest === other.rest) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (closing_loc.nil? == other.closing_loc.nil?)
    end
  end

# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
  #
  #     bar if foo
  #     ^^^^^^^^^^
  #
  #     if foo then bar end
  #     ^^^^^^^^^^^^^^^^^^^
  #
  #     foo ? bar : baz
  #     ^^^^^^^^^^^^^^^
  class IfNode < Node
    # Initialize a new IfNode node.
    def initialize(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @if_keyword_loc = if_keyword_loc
      @predicate = predicate
      @then_keyword_loc = then_keyword_loc
      @statements = statements
      @subsequent = subsequent
      @end_keyword_loc = end_keyword_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_if_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [predicate, statements, subsequent]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << predicate
      compact << statements if statements
      compact << subsequent if subsequent
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*if_keyword_loc, predicate, *then_keyword_loc, *statements, *subsequent, *end_keyword_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, if_keyword_loc: self.if_keyword_loc, predicate: self.predicate, then_keyword_loc: self.then_keyword_loc, statements: self.statements, subsequent: self.subsequent, end_keyword_loc: self.end_keyword_loc)
      IfNode.new(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, if_keyword_loc: if_keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, subsequent: subsequent, end_keyword_loc: end_keyword_loc }
    end

# The location of the `if` keyword if present.
    #
    #     bar if foo
    #         ^^
    #
    # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
    def if_keyword_loc
      location = @if_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @if_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the if_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_if_keyword_loc(repository)
      repository.enter(node_id, :if_keyword_loc) unless @if_keyword_loc.nil?
    end

# The node for the condition the `IfNode` is testing.
    #
    #     if foo
    #        ^^^
    #       bar
    #     end
    #
    #     bar if foo
    #            ^^^
    #
    #     foo ? bar : baz
    #     ^^^
    attr_reader :predicate

# The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
    #
    #     if foo then bar end
    #            ^^^^
    #
    #     a ? b : c
    #       ^
    def then_keyword_loc
      location = @then_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @then_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the then_keyword_loc location using the given saved source so that
    # it can be retrieved later.
    def save_then_keyword_loc(repository)
      repository.enter(node_id, :then_keyword_loc) unless @then_keyword_loc.nil?
    end

# Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
    #
    #     if foo
    #       bar
    #       ^^^
    #       baz
    #       ^^^
    #     end
    attr_reader :statements

# Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
    #
    #     if foo
    #       bar
    #     elsif baz
    #     ^^^^^^^^^
    #       qux
    #       ^^^
    #     end
    #     ^^^
    #
    #     if foo then bar else baz end
    #                     ^^^^^^^^^^^^
    attr_reader :subsequent

# The location of the `end` keyword if present, `nil` otherwise.
    #
    #     if foo
    #       bar
    #     end
    #     ^^^
    def end_keyword_loc
      location = @end_keyword_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# def if_keyword: () -> String?
    def if_keyword
      if_keyword_loc&.slice
    end

# def then_keyword: () -> String?
    def then_keyword
      then_keyword_loc&.slice
    end

# def end_keyword: () -> String?
    def end_keyword
      end_keyword_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :if_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :if_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(IfNode) &&
        (if_keyword_loc.nil? == other.if_keyword_loc.nil?) &&
        (predicate === other.predicate) &&
        (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
        (statements === other.statements) &&
        (subsequent === other.subsequent) &&
        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
    end
  end

# Represents an imaginary number literal.
  #
  #     1.0i
  #     ^^^^
  class ImaginaryNode < Node
    # Initialize a new ImaginaryNode node.
    def initialize(source, node_id, location, flags, numeric)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @numeric = numeric
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_imaginary_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [numeric]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [numeric]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [numeric] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, numeric: self.numeric)
      ImaginaryNode.new(source, node_id, location, flags, numeric)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, numeric: numeric }
    end

# attr_reader numeric: FloatNode | IntegerNode | RationalNode
    attr_reader :numeric

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :imaginary_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :imaginary_node
    end

# Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
  #
  #     { foo: }
  #       ^^^^
  #
  #     { Foo: }
  #       ^^^^
  #
  #     foo in { bar: }
  #              ^^^^
  class ImplicitNode < Node
    # Initialize a new ImplicitNode node.
    def initialize(source, node_id, location, flags, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_implicit_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [value]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      [value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value)
      ImplicitNode.new(source, node_id, location, flags, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, value: value }
    end

# attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode
    attr_reader :value

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :implicit_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :implicit_node
    end

# Represents using a trailing comma to indicate an implicit rest parameter.
  #
  #     foo { |bar,| }
  #               ^
  #
  #     foo in [bar,]
  #                ^
  #
  #     for foo, in bar do end
  #            ^
  #
  #     foo, = bar
  #        ^
  class ImplicitRestNode < Node
    # Initialize a new ImplicitRestNode node.
    def initialize(source, node_id, location, flags)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_implicit_rest_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      []
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      []
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags)
      ImplicitRestNode.new(source, node_id, location, flags)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location }
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :implicit_rest_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :implicit_rest_node
    end

# Represents the use of the `in` keyword in a case statement.
  #
  #     case a; in b then c end
  #             ^^^^^^^^^^^
  class InNode < Node
    # Initialize a new InNode node.
    def initialize(source, node_id, location, flags, pattern, statements, in_loc, then_loc)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @pattern = pattern
      @statements = statements
      @in_loc = in_loc
      @then_loc = then_loc
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_in_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [pattern, statements]
    end

# def compact_child_nodes: () -> Array[Node]
    def compact_child_nodes
      compact = [] #: Array[Prism::node]
      compact << pattern
      compact << statements if statements
      compact
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [pattern, *statements, in_loc, *then_loc] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, pattern: self.pattern, statements: self.statements, in_loc: self.in_loc, then_loc: self.then_loc)
      InNode.new(source, node_id, location, flags, pattern, statements, in_loc, then_loc)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, pattern: pattern, statements: statements, in_loc: in_loc, then_loc: then_loc }
    end

# attr_reader pattern: Prism::node
    attr_reader :pattern

# attr_reader statements: StatementsNode?
    attr_reader :statements

# attr_reader in_loc: Location
    def in_loc
      location = @in_loc
      return location if location.is_a?(Location)
      @in_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
    end

# Save the in_loc location using the given saved source so that
    # it can be retrieved later.
    def save_in_loc(repository)
      repository.enter(node_id, :in_loc)
    end

# attr_reader then_loc: Location?
    def then_loc
      location = @then_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @then_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the then_loc location using the given saved source so that
    # it can be retrieved later.
    def save_then_loc(repository)
      repository.enter(node_id, :then_loc) unless @then_loc.nil?
    end

# def in: () -> String
    def in
      in_loc.slice
    end

# def then: () -> String?
    def then
      then_loc&.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :in_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :in_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(InNode) &&
        (pattern === other.pattern) &&
        (statements === other.statements) &&
        (in_loc.nil? == other.in_loc.nil?) &&
        (then_loc.nil? == other.then_loc.nil?)
    end
  end

# Represents the use of the `&&=` operator on a call to the `[]` method.
  #
  #     foo.bar[baz] &&= value
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class IndexAndWriteNode < Node
    # Initialize a new IndexAndWriteNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @opening_loc = opening_loc
      @arguments = arguments
      @closing_loc = closing_loc
      @block = block
      @operator_loc = operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_index_and_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, arguments, block, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, operator_loc: self.operator_loc, value: self.value)
      IndexAndWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value }
    end

# def safe_navigation?: () -> bool
    def safe_navigation?
      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
    end

# def variable_call?: () -> bool
    def variable_call?
      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
    end

# def attribute_write?: () -> bool
    def attribute_write?
      flags.anybits?(CallNodeFlags::ATTRIBUTE_WRITE)
    end

# def ignore_visibility?: () -> bool
    def ignore_visibility?
      flags.anybits?(CallNodeFlags::IGNORE_VISIBILITY)
    end

# attr_reader receiver: Prism::node?
    attr_reader :receiver

# attr_reader call_operator_loc: Location?
    def call_operator_loc
      location = @call_operator_loc
      case location
      when nil
        nil
      when Location
        location
      else
        @call_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
      end
    end

# Save the opening_loc location using the given saved source so that
    # it can be retrieved later.
    def save_opening_loc(repository)
      repository.enter(node_id, :opening_loc)
    end

# attr_reader arguments: ArgumentsNode?
    attr_reader :arguments

# Save the closing_loc location using the given saved source so that
    # it can be retrieved later.
    def save_closing_loc(repository)
      repository.enter(node_id, :closing_loc)
    end

# attr_reader block: BlockArgumentNode?
    attr_reader :block

# Save the operator_loc location using the given saved source so that
    # it can be retrieved later.
    def save_operator_loc(repository)
      repository.enter(node_id, :operator_loc)
    end

# attr_reader value: Prism::node
    attr_reader :value

# def call_operator: () -> String?
    def call_operator
      call_operator_loc&.slice
    end

# def opening: () -> String
    def opening
      opening_loc.slice
    end

# def closing: () -> String
    def closing
      closing_loc.slice
    end

# def operator: () -> String
    def operator
      operator_loc.slice
    end

# def inspect -> String
    def inspect
      InspectVisitor.compose(self)
    end

# Return a symbol representation of this node type. See `Node#type`.
    def type
      :index_and_write_node
    end

# Return a symbol representation of this node type. See `Node::type`.
    def self.type
      :index_and_write_node
    end

# Implements case-equality for the node. This is effectively == but without
    # comparing the value of locations. Locations are checked only for presence.
    def ===(other)
      other.is_a?(IndexAndWriteNode) &&
        (flags === other.flags) &&
        (receiver === other.receiver) &&
        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
        (opening_loc.nil? == other.opening_loc.nil?) &&
        (arguments === other.arguments) &&
        (closing_loc.nil? == other.closing_loc.nil?) &&
        (block === other.block) &&
        (operator_loc.nil? == other.operator_loc.nil?) &&
        (value === other.value)
    end
  end

# Represents the use of an assignment operator on a call to `[]`.
  #
  #     foo.bar[baz] += value
  #     ^^^^^^^^^^^^^^^^^^^^^
  class IndexOperatorWriteNode < Node
    # Initialize a new IndexOperatorWriteNode node.
    def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value)
      @source = source
      @node_id = node_id
      @location = location
      @flags = flags
      @receiver = receiver
      @call_operator_loc = call_operator_loc
      @opening_loc = opening_loc
      @arguments = arguments
      @closing_loc = closing_loc
      @block = block
      @binary_operator = binary_operator
      @binary_operator_loc = binary_operator_loc
      @value = value
    end

# def accept: (Visitor visitor) -> void
    def accept(visitor)
      visitor.visit_index_operator_write_node(self)
    end

# def child_nodes: () -> Array[nil | Node]
    def child_nodes
      [receiver, arguments, block, value]
    end

# def comment_targets: () -> Array[Node | Location]
    def comment_targets
      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, binary_operator_loc, value] #: Array[Prism::node | Location]
    end

# def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value)
      IndexOperatorWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value)
    end

# def deconstruct: () -> Array[nil | Node]
    alias deconstruct child_nodes

# def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
    def deconstruct_keys(keys)
      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, binary_operator: binary_operator, binary_operator_loc: binary_operator_loc, value: value }
    end