diff --git a/sorbet/rbi/gems/prism@0.20.0.rbi b/sorbet/rbi/gems/prism@0.20.0.rbi
new file mode 100644
index 000000000..a4e35566e
--- /dev/null
+++ b/sorbet/rbi/gems/prism@0.20.0.rbi
@@ -0,0 +1,29521 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `prism` gem.
+# Please instead update this file by running `bin/tapioca gem prism`.
+
+# The Prism Ruby parser.
+#
+# "Parsing Ruby is suddenly manageable!"
+#   - You, hopefully
+#
+# source://prism-0.20.0/lib/prism.rb:8
+module Prism
+  class << self
+    # Mirror the Prism.dump API by using the serialization API.
+    def dump(*_arg0); end
+
+    # Mirror the Prism.dump_file API by using the serialization API.
+    def dump_file(*_arg0); end
+
+    # Mirror the Prism.lex API by using the serialization API.
+    def lex(*_arg0); end
+
+    # :call-seq:
+    #   Prism::lex_compat(source, **options) -> ParseResult
+    #
+    # Returns a parse result whose value is an array of tokens that closely
+    # resembles the return value of Ripper::lex. The main difference is that the
+    # `:on_sp` token is not emitted.
+    #
+    # For supported options, see Prism::parse.
+    #
+    # source://prism-0.20.0/lib/prism.rb:47
+    def lex_compat(source, **options); end
+
+    # Mirror the Prism.lex_file API by using the serialization API.
+    def lex_file(*_arg0); end
+
+    # :call-seq:
+    #   Prism::lex_ripper(source) -> Array
+    #
+    # This lexes with the Ripper lex. It drops any space events but otherwise
+    # returns the same tokens. Raises SyntaxError if the syntax in source is
+    # invalid.
+    #
+    # source://prism-0.20.0/lib/prism.rb:57
+    def lex_ripper(source); end
+
+    # :call-seq:
+    #   Prism::load(source, serialized) -> ParseResult
+    #
+    # Load the serialized AST using the source as a reference into a tree.
+    #
+    # source://prism-0.20.0/lib/prism.rb:65
+    def load(source, serialized); end
+
+    # Mirror the Prism.parse API by using the serialization API.
+    def parse(*_arg0); end
+
+    # Mirror the Prism.parse_comments API by using the serialization API.
+    def parse_comments(*_arg0); end
+
+    # :call-seq:
+    #   Prism::parse_failure?(source, **options) -> bool
+    #
+    # Returns true if the source parses with errors.
+    #
+    # @return [Boolean]
+    #
+    # source://prism-0.20.0/lib/prism.rb:73
+    def parse_failure?(source, **options); end
+
+    # Mirror the Prism.parse_file API by using the serialization API. This uses
+    # native strings instead of Ruby strings because it allows us to use mmap when
+    # it is available.
+    def parse_file(*_arg0); end
+
+    # Mirror the Prism.parse_file_comments API by using the serialization
+    # API. This uses native strings instead of Ruby strings because it allows us
+    # to use mmap when it is available.
+    def parse_file_comments(*_arg0); end
+
+    # :call-seq:
+    #   Prism::parse_file_failure?(filepath, **options) -> bool
+    #
+    # Returns true if the file at filepath parses with errors.
+    #
+    # @return [Boolean]
+    #
+    # source://prism-0.20.0/lib/prism.rb:81
+    def parse_file_failure?(filepath, **options); end
+
+    # Mirror the Prism.parse_file_success? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_file_success?(*_arg0); end
+
+    # Mirror the Prism.parse_lex API by using the serialization API.
+    def parse_lex(*_arg0); end
+
+    # Mirror the Prism.parse_lex_file API by using the serialization API.
+    def parse_lex_file(*_arg0); end
+
+    # Mirror the Prism.parse_success? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_success?(*_arg0); end
+  end
+end
+
+# Represents the use of the `alias` keyword to alias a global variable.
+#
+#     alias $foo $bar
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:91
+class Prism::AliasGlobalVariableNode < ::Prism::Node
+  # def initialize: (Node new_name, Node old_name, Location keyword_loc, Location location) -> void
+  #
+  # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:101
+  def initialize(new_name, old_name, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:109
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:114
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:124
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:119
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AliasGlobalVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:129
+  sig { params(params: T.untyped).returns(Prism::AliasGlobalVariableNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:114
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Node, old_name: Node, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:142
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:152
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:147
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:98
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader new_name: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:92
+  sig { returns(Prism::Node) }
+  def new_name; end
+
+  # attr_reader old_name: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:95
+  sig { returns(Prism::Node) }
+  def old_name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:176
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:186
+    def type; end
+  end
+end
+
+# Represents the use of the `alias` keyword to alias a method.
+#
+#     alias foo bar
+#     ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:196
+class Prism::AliasMethodNode < ::Prism::Node
+  # def initialize: (Node new_name, Node old_name, Location keyword_loc, Location location) -> void
+  #
+  # @return [AliasMethodNode] a new instance of AliasMethodNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:206
+  def initialize(new_name, old_name, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:214
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:219
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:229
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:224
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AliasMethodNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:234
+  sig { params(params: T.untyped).returns(Prism::AliasMethodNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:219
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Node, old_name: Node, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:247
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:257
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:252
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:203
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader new_name: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:197
+  sig { returns(Prism::Node) }
+  def new_name; end
+
+  # attr_reader old_name: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:200
+  sig { returns(Prism::Node) }
+  def old_name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:281
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:291
+    def type; end
+  end
+end
+
+# Represents an alternation pattern in pattern matching.
+#
+#     foo => bar | baz
+#            ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:301
+class Prism::AlternationPatternNode < ::Prism::Node
+  # def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+  #
+  # @return [AlternationPatternNode] a new instance of AlternationPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:311
+  def initialize(left, right, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:319
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:324
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:334
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:329
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AlternationPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:339
+  sig { params(params: T.untyped).returns(Prism::AlternationPatternNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:324
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:352
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:362
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader left: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:302
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:357
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:308
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader right: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:305
+  sig { returns(Prism::Node) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:386
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:396
+    def type; end
+  end
+end
+
+# Represents the use of the `&&` operator or the `and` keyword.
+#
+#     left and right
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:412
+class Prism::AndNode < ::Prism::Node
+  # def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+  #
+  # @return [AndNode] a new instance of AndNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:431
+  def initialize(left, right, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:439
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:444
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:454
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:449
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AndNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:459
+  sig { params(params: T.untyped).returns(Prism::AndNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:444
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:472
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:482
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # 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
+  #     ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:413
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:477
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `and` keyword or the `&&` operator.
+  #
+  #     left and right
+  #          ^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:428
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents the right 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 && right
+  #             ^^^^^
+  #
+  #     1 and 2
+  #           ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:422
+  sig { returns(Prism::Node) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:506
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:516
+    def type; end
+  end
+end
+
+# Represents a set of arguments to a method or a keyword.
+#
+#     return foo, bar, baz
+#            ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:526
+class Prism::ArgumentsNode < ::Prism::Node
+  # def initialize: (Integer flags, Array[Node] arguments, Location location) -> void
+  #
+  # @return [ArgumentsNode] a new instance of ArgumentsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:533
+  def initialize(flags, arguments, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:540
+  def accept(visitor); end
+
+  # attr_reader arguments: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:530
+  sig { returns(T::Array[Prism::Node]) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:545
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:555
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:550
+  def compact_child_nodes; end
+
+  # def contains_keyword_splat?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:577
+  sig { returns(T::Boolean) }
+  def contains_keyword_splat?; end
+
+  # def copy: (**params) -> ArgumentsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:560
+  sig { params(params: T.untyped).returns(Prism::ArgumentsNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:545
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, arguments: Array[Node], location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:572
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:582
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:604
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:527
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:614
+    def type; end
+  end
+end
+
+# Flags for arguments nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17551
+module Prism::ArgumentsNodeFlags; end
+
+# if arguments contain keyword splat
+#
+# source://prism-0.20.0/lib/prism/node.rb:17553
+Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
+#
+#     [1, 2, 3]
+#     ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:624
+class Prism::ArrayNode < ::Prism::Node
+  # def initialize: (Integer flags, Array[Node] elements, Location? opening_loc, Location? closing_loc, Location location) -> void
+  #
+  # @return [ArrayNode] a new instance of ArrayNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:637
+  def initialize(flags, elements, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:646
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:651
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:695
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:634
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:661
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:656
+  def compact_child_nodes; end
+
+  # def contains_splat?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:685
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
+  # def copy: (**params) -> ArrayNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:666
+  sig { params(params: T.untyped).returns(Prism::ArrayNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:651
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:680
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:628
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:700
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:690
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:631
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:724
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:625
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:734
+    def type; end
+  end
+end
+
+# Flags for array nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17557
+module Prism::ArrayNodeFlags; end
+
+# if array contains splat nodes
+#
+# source://prism-0.20.0/lib/prism/node.rb:17559
+Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# Represents an array pattern in pattern matching.
+#
+#     foo in 1, 2
+#     ^^^^^^^^^^^
+#
+#     foo in [1, 2]
+#     ^^^^^^^^^^^^^
+#
+#     foo in *1
+#     ^^^^^^^^^
+#
+#     foo in Bar[]
+#     ^^^^^^^^^^^^
+#
+#     foo in Bar[1, 2, 3]
+#     ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:756
+class Prism::ArrayPatternNode < ::Prism::Node
+  # def initialize: (Node? constant, Array[Node] requireds, Node? rest, Array[Node] posts, Location? opening_loc, Location? closing_loc, Location location) -> void
+  #
+  # @return [ArrayPatternNode] a new instance of ArrayPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:775
+  def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:786
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:791
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:837
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:772
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:806
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:796
+  def compact_child_nodes; end
+
+  # attr_reader constant: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:757
+  sig { returns(T.nilable(Prism::Node)) }
+  def constant; end
+
+  # def copy: (**params) -> ArrayPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:811
+  sig { params(params: T.untyped).returns(Prism::ArrayPatternNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:791
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:827
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:842
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:832
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:769
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader posts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:766
+  sig { returns(T::Array[Prism::Node]) }
+  def posts; end
+
+  # attr_reader requireds: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:760
+  sig { returns(T::Array[Prism::Node]) }
+  def requireds; end
+
+  # attr_reader rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:763
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:877
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:887
+    def type; end
+  end
+end
+
+# Represents a hash key/value pair.
+#
+#     { a => b }
+#       ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:906
+class Prism::AssocNode < ::Prism::Node
+  # def initialize: (Node key, Node value, Location? operator_loc, Location location) -> void
+  #
+  # @return [AssocNode] a new instance of AssocNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:925
+  def initialize(key, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:933
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:938
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:948
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:943
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AssocNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:953
+  sig { params(params: T.untyped).returns(Prism::AssocNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:938
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { key: Node, value: Node, operator_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:966
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:976
+  def inspect(inspector = T.unsafe(nil)); 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 }
+  #       ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:907
+  sig { returns(Prism::Node) }
+  def key; end
+
+  # def operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:971
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # The location of the `=>` operator, if present.
+  #
+  #     { foo => bar }
+  #           ^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:922
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1000
+  def type; end
+
+  # 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 }
+  #          ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:916
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1010
+    def type; end
+  end
+end
+
+# Represents a splat in a hash literal.
+#
+#     { **foo }
+#       ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1023
+class Prism::AssocSplatNode < ::Prism::Node
+  # def initialize: (Node? value, Location operator_loc, Location location) -> void
+  #
+  # @return [AssocSplatNode] a new instance of AssocSplatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1033
+  def initialize(value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1040
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1045
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1057
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1050
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> AssocSplatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1062
+  sig { params(params: T.untyped).returns(Prism::AssocSplatNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1045
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Node?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1074
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1084
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1079
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `**` operator.
+  #
+  #     { **x }
+  #       ^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1030
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1110
+  def type; end
+
+  # The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
+  #
+  #     { **foo }
+  #         ^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1024
+  sig { returns(T.nilable(Prism::Node)) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1120
+    def type; end
+  end
+end
+
+Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
+
+# Represents reading a reference to a field in the previous match.
+#
+#     $'
+#     ^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1134
+class Prism::BackReferenceReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1138
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1144
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1149
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1159
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1154
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BackReferenceReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1164
+  sig { params(params: T.untyped).returns(Prism::BackReferenceReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1149
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1175
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1180
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # The name of the back-reference variable, including the leading `$`.
+  #
+  #     $& # name `:$&`
+  #
+  #     $+ # name `:$+`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1135
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1200
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1210
+    def type; end
+  end
+end
+
+# A class that knows how to walk down the tree. None of the individual visit
+# methods are implemented on this visitor, so it forces the consumer to
+# implement each one that they need. For a default implementation that
+# continues walking the tree, see the Visitor class.
+#
+# source://prism-0.20.0/lib/prism/visitor.rb:13
+class Prism::BasicVisitor
+  # Calls `accept` on the given node if it is not `nil`, which in turn should
+  # call back into this visitor by calling the appropriate `visit_*` method.
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:16
+  def visit(node); end
+
+  # Visits each node in `nodes` by calling `accept` on each one.
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:21
+  def visit_all(nodes); end
+
+  # Visits the child nodes of `node` by calling `accept` on each one.
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_child_nodes(node); end
+end
+
+# Represents a begin statement.
+#
+#     begin
+#       foo
+#     end
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1222
+class Prism::BeginNode < ::Prism::Node
+  # def initialize: (Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc, Location location) -> void
+  #
+  # @return [BeginNode] a new instance of BeginNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1241
+  def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1252
+  def accept(visitor); end
+
+  # def begin_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1302
+  sig { returns(T.nilable(String)) }
+  def begin_keyword; end
+
+  # attr_reader begin_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1223
+  sig { returns(T.nilable(Prism::Location)) }
+  def begin_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1261
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1276
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1266
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BeginNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1281
+  sig { params(params: T.untyped).returns(Prism::BeginNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1261
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1297
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1232
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def else_clause; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1307
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1238
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # attr_reader ensure_clause: EnsureNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1235
+  sig { returns(T.nilable(Prism::EnsureNode)) }
+  def ensure_clause; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1312
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader rescue_clause: RescueNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1229
+  sig { returns(T.nilable(Prism::RescueNode)) }
+  def rescue_clause; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:1256
+  def set_newline_flag(newline_marked); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1226
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1357
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1367
+    def type; end
+  end
+end
+
+# Represents block method arguments.
+#
+#     bar(&args)
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1377
+class Prism::BlockArgumentNode < ::Prism::Node
+  # def initialize: (Node? expression, Location operator_loc, Location location) -> void
+  #
+  # @return [BlockArgumentNode] a new instance of BlockArgumentNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1384
+  def initialize(expression, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1391
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1396
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1408
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1401
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BlockArgumentNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1413
+  sig { params(params: T.untyped).returns(Prism::BlockArgumentNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1396
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1425
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1378
+  sig { returns(T.nilable(Prism::Node)) }
+  def expression; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1435
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1430
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1381
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1461
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1471
+    def type; end
+  end
+end
+
+# Represents a block local variable.
+#
+#     a { |; b| }
+#            ^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1481
+class Prism::BlockLocalVariableNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol name, Location location) -> void
+  #
+  # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1488
+  def initialize(flags, name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1495
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1500
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1510
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1505
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BlockLocalVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1515
+  sig { params(params: T.untyped).returns(Prism::BlockLocalVariableNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1500
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1527
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1537
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1485
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1532
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1559
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1482
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1569
+    def type; end
+  end
+end
+
+# Represents a block of ruby code.
+#
+#     [1, 2, 3].each { |i| puts x }
+#                    ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1579
+class Prism::BlockNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, Node? parameters, Node? body, Location opening_loc, Location closing_loc, Location location) -> void
+  #
+  # @return [BlockNode] a new instance of BlockNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1595
+  def initialize(locals, parameters, body, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1605
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1586
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1610
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1653
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1592
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1623
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1615
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BlockNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1628
+  sig { params(params: T.untyped).returns(Prism::BlockNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1610
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1643
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1658
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1580
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1648
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1589
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parameters: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1583
+  sig { returns(T.nilable(Prism::Node)) }
+  def parameters; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1692
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1702
+    def type; end
+  end
+end
+
+# Represents a block parameter to a method, block, or lambda definition.
+#
+#     def a(&b)
+#           ^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:1713
+class Prism::BlockParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+  #
+  # @return [BlockParameterNode] a new instance of BlockParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1726
+  def initialize(flags, name, name_loc, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1735
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1740
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1750
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1745
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BlockParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1755
+  sig { params(params: T.untyped).returns(Prism::BlockParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1740
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1769
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1784
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1717
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1720
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1779
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1723
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1774
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1812
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1714
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1822
+    def type; end
+  end
+end
+
+# Represents a block's parameters declaration.
+#
+#     -> (a, b = 1; local) { }
+#        ^^^^^^^^^^^^^^^^^
+#
+#     foo do |a, b = 1; local|
+#            ^^^^^^^^^^^^^^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:1836
+class Prism::BlockParametersNode < ::Prism::Node
+  # def initialize: (ParametersNode? parameters, Array[Node] locals, Location? opening_loc, Location? closing_loc, Location location) -> void
+  #
+  # @return [BlockParametersNode] a new instance of BlockParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1849
+  def initialize(parameters, locals, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1858
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1863
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1905
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1846
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1876
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1868
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BlockParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1881
+  sig { params(params: T.untyped).returns(Prism::BlockParametersNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1863
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1895
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1910
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1840
+  sig { returns(T::Array[Prism::Node]) }
+  def locals; end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1900
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1843
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1837
+  sig { returns(T.nilable(Prism::ParametersNode)) }
+  def parameters; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1938
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:1948
+    def type; end
+  end
+end
+
+# Represents the use of the `break` keyword.
+#
+#     break foo
+#     ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:1958
+class Prism::BreakNode < ::Prism::Node
+  # def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+  #
+  # @return [BreakNode] a new instance of BreakNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1965
+  def initialize(arguments, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1972
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1959
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1977
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1989
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1982
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> BreakNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1994
+  sig { params(params: T.untyped).returns(Prism::BreakNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1977
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2006
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2016
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2011
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:1962
+  sig { returns(Prism::Location) }
+  def keyword_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2042
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2052
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call.
+#
+#     foo.bar &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2062
+class Prism::CallAndWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [CallAndWriteNode] a new instance of CallAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2087
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2100
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2156
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2166
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2069
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2105
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2118
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2110
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CallAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2123
+  sig { params(params: T.untyped).returns(Prism::CallAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2105
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2141
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2161
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2181
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def message: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2171
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2072
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2176
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2081
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2075
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2066
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2146
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2215
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2084
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2151
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2078
+  sig { returns(Symbol) }
+  def write_name; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2063
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2225
+    def type; end
+  end
+end
+
+# Represents a method call, in all of the various forms that can take.
+#
+#     foo
+#     ^^^
+#
+#     foo()
+#     ^^^^^
+#
+#     +foo
+#     ^^^^
+#
+#     foo + bar
+#     ^^^^^^^^^
+#
+#     foo.bar
+#     ^^^^^^^
+#
+#     foo&.bar
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2250
+class Prism::CallNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Node? block, Location location) -> void
+  #
+  # @return [CallNode] a new instance of CallNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2287
+  def initialize(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2301
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2278
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2359
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2284
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2369
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2266
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2306
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2384
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2281
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2320
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2311
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CallNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2325
+  sig { params(params: T.untyped).returns(Prism::CallNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2306
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2344
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2364
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2389
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def message: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2374
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2272
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2269
+  sig { returns(Symbol) }
+  def name; end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2379
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2275
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; 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
+  #     ^^^
+  #
+  #     +foo
+  #      ^^^
+  #
+  #     foo + bar
+  #     ^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2263
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2349
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2433
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2354
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2251
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2443
+    def type; end
+  end
+end
+
+# Flags for call nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17563
+module Prism::CallNodeFlags; end
+
+# a call that is an attribute write, so the value being written should be returned
+#
+# source://prism-0.20.0/lib/prism/node.rb:17571
+Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
+
+# a call that ignores method visibility
+#
+# source://prism-0.20.0/lib/prism/node.rb:17574
+Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer)
+
+# &. operator
+#
+# source://prism-0.20.0/lib/prism/node.rb:17565
+Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer)
+
+# a call that could have been a local variable
+#
+# source://prism-0.20.0/lib/prism/node.rb:17568
+Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer)
+
+# Represents the use of an assignment operator on a call.
+#
+#     foo.bar += baz
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2453
+class Prism::CallOperatorWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol operator, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2481
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2495
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2552
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2562
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2460
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2500
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2513
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2505
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CallOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2518
+  sig { params(params: T.untyped).returns(Prism::CallOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2500
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2537
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2557
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2572
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def message: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2567
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2463
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2472
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2475
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2466
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2457
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2542
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2607
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2478
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2547
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2469
+  sig { returns(Symbol) }
+  def write_name; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2454
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2617
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call.
+#
+#     foo.bar ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2627
+class Prism::CallOrWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [CallOrWriteNode] a new instance of CallOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2652
+  def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2665
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2721
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2731
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2634
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2670
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2683
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2675
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CallOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2688
+  sig { params(params: T.untyped).returns(Prism::CallOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2670
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2706
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2726
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2746
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def message: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2736
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2637
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2741
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2646
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2640
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2631
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2711
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2780
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2649
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2716
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2643
+  sig { returns(Symbol) }
+  def write_name; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2628
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2790
+    def type; end
+  end
+end
+
+# Represents assigning to a method call.
+#
+#     foo.bar, = 1
+#     ^^^^^^^
+#
+#     begin
+#     rescue => foo.bar
+#               ^^^^^^^
+#     end
+#
+#     for foo.bar in baz do end
+#         ^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2808
+class Prism::CallTargetNode < ::Prism::Node
+  # def initialize: (Integer flags, Node receiver, Location call_operator_loc, Symbol name, Location message_loc, Location location) -> void
+  #
+  # @return [CallTargetNode] a new instance of CallTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2824
+  def initialize(flags, receiver, call_operator_loc, name, message_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2834
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2884
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2894
+  sig { returns(String) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2815
+  sig { returns(Prism::Location) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2839
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2849
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2844
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CallTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2854
+  sig { params(params: T.untyped).returns(Prism::CallTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2839
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2869
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2889
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2904
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def message: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2899
+  sig { returns(String) }
+  def message; end
+
+  # attr_reader message_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2821
+  sig { returns(Prism::Location) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2818
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader receiver: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2812
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2874
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2930
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2879
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2809
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:2940
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable in pattern matching.
+#
+#     foo => [bar => baz]
+#            ^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:2950
+class Prism::CapturePatternNode < ::Prism::Node
+  # def initialize: (Node value, Node target, Location operator_loc, Location location) -> void
+  #
+  # @return [CapturePatternNode] a new instance of CapturePatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2960
+  def initialize(value, target, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2968
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2973
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2983
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2978
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> CapturePatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2988
+  sig { params(params: T.untyped).returns(Prism::CapturePatternNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2973
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, target: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3001
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3011
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3006
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2957
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2954
+  sig { returns(Prism::Node) }
+  def target; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3035
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:2951
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3045
+    def type; end
+  end
+end
+
+# Represents the use of a case statement for pattern matching.
+#
+#     case true
+#     in false
+#     end
+#     ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3057
+class Prism::CaseMatchNode < ::Prism::Node
+  # def initialize: (Node? predicate, Array[Node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+  #
+  # @return [CaseMatchNode] a new instance of CaseMatchNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3073
+  def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3083
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3127
+  sig { returns(String) }
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3067
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3088
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3102
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3093
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3061
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  # attr_reader consequent: ElseNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3064
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def consequent; end
+
+  # def copy: (**params) -> CaseMatchNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3107
+  sig { params(params: T.untyped).returns(Prism::CaseMatchNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3088
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3122
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3132
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3070
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3137
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader predicate: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3058
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3171
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3181
+    def type; end
+  end
+end
+
+# Represents the use of a case statement.
+#
+#     case true
+#     when false
+#     end
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3193
+class Prism::CaseNode < ::Prism::Node
+  # def initialize: (Node? predicate, Array[Node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+  #
+  # @return [CaseNode] a new instance of CaseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3209
+  def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3219
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3263
+  sig { returns(String) }
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3203
+  sig { returns(Prism::Location) }
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3224
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3238
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3229
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3197
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  # attr_reader consequent: ElseNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3200
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def consequent; end
+
+  # def copy: (**params) -> CaseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3243
+  sig { params(params: T.untyped).returns(Prism::CaseNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3224
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3258
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3268
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3206
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3273
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader predicate: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3194
+  sig { returns(T.nilable(Prism::Node)) }
+  def predicate; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3307
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3317
+    def type; end
+  end
+end
+
+# Represents a class declaration involving the `class` keyword.
+#
+#     class Foo end
+#     ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3327
+class Prism::ClassNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, Location class_keyword_loc, Node constant_path, Location? inheritance_operator_loc, Node? superclass, Node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+  #
+  # @return [ClassNode] a new instance of ClassNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3352
+  def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3365
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3343
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3370
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3412
+  sig { returns(String) }
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3331
+  sig { returns(Prism::Location) }
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3384
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3375
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3334
+  sig { returns(Prism::Node) }
+  def constant_path; end
+
+  # def copy: (**params) -> ClassNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3389
+  sig { params(params: T.untyped).returns(Prism::ClassNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3370
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3407
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3422
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3346
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def inheritance_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3417
+  sig { returns(T.nilable(String)) }
+  def inheritance_operator; end
+
+  # attr_reader inheritance_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3337
+  sig { returns(T.nilable(Prism::Location)) }
+  def inheritance_operator_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3427
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3328
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3349
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader superclass: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3340
+  sig { returns(T.nilable(Prism::Node)) }
+  def superclass; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3465
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3475
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a class variable.
+#
+#     @@target &&= value
+#     ^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3485
+class Prism::ClassVariableAndWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3498
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3507
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3512
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3522
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3517
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3527
+  sig { params(params: T.untyped).returns(Prism::ClassVariableAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3512
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3541
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3551
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3486
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3489
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3546
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3492
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3575
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3495
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3585
+    def type; end
+  end
+end
+
+# Represents assigning to a class variable using an operator that isn't `=`.
+#
+#     @@target += value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3595
+class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+  #
+  # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3611
+  def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3621
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3626
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3636
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3631
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3641
+  sig { params(params: T.untyped).returns(Prism::ClassVariableOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3626
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3656
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3661
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3596
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3599
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3608
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3602
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3686
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3605
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3696
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a class variable.
+#
+#     @@target ||= value
+#     ^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3706
+class Prism::ClassVariableOrWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3719
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3728
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3733
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3743
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3738
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3748
+  sig { params(params: T.untyped).returns(Prism::ClassVariableOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3733
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3762
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3772
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3707
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3710
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3767
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3713
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3796
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3716
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3806
+    def type; end
+  end
+end
+
+# Represents referencing a class variable.
+#
+#     @@foo
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3820
+class Prism::ClassVariableReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3824
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3830
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3835
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3845
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3840
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3850
+  sig { params(params: T.untyped).returns(Prism::ClassVariableReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3835
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3861
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3866
+  def inspect(inspector = T.unsafe(nil)); 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   # name `:@@abc`
+  #
+  #     @@_test # name `:@@_test`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3821
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3886
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3896
+    def type; end
+  end
+end
+
+# Represents writing to a class variable in a context that doesn't have an explicit value.
+#
+#     @@foo, @@bar = baz
+#     ^^^^^  ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3906
+class Prism::ClassVariableTargetNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3910
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3916
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3921
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3931
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3926
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3936
+  sig { params(params: T.untyped).returns(Prism::ClassVariableTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3921
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3947
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3952
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3907
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3972
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:3982
+    def type; end
+  end
+end
+
+# Represents writing to a class variable.
+#
+#     @@foo = 1
+#     ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:3992
+class Prism::ClassVariableWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Node value, Location? operator_loc, Location location) -> void
+  #
+  # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4005
+  def initialize(name, name_loc, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4014
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4019
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4029
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4024
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ClassVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4034
+  sig { params(params: T.untyped).returns(Prism::ClassVariableWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4019
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4048
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4058
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3993
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3996
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4053
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4002
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4082
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:3999
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4092
+    def type; end
+  end
+end
+
+# This represents a comment that was encountered during parsing. It is the
+# base class for all comment types.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:228
+class Prism::Comment
+  # Create a new comment object with the given location.
+  #
+  # @return [Comment] a new instance of Comment
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:233
+  def initialize(location); end
+
+  # Implement the hash pattern matching interface for Comment.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:238
+  def deconstruct_keys(keys); end
+
+  # The location of this comment in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:230
+  sig { returns(Prism::Location) }
+  def location; end
+
+  sig { returns(T::Boolean) }
+  def trailing?; end
+end
+
+# A compiler is a visitor that returns the value of each node as it visits.
+# This is as opposed to a visitor which will only walk the tree. This can be
+# useful when you are trying to compile a tree into a different format.
+#
+# For example, to build a representation of the tree as s-expressions, you
+# could write:
+#
+#     class SExpressions < Prism::Compiler
+#       def visit_arguments_node(node) = [:arguments, super]
+#       def visit_call_node(node) = [:call, super]
+#       def visit_integer_node(node) = [:integer]
+#       def visit_program_node(node) = [:program, super]
+#     end
+#
+#     Prism.parse("1 + 2").value.accept(SExpressions.new)
+#     # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
+#
+# source://prism-0.20.0/lib/prism/compiler.rb:26
+class Prism::Compiler
+  # Visit an individual node.
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:28
+  def visit(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasGlobalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_alias_global_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasMethodNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_alias_method_node(node); end
+
+  # Visit a list of nodes.
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:33
+  def visit_all(nodes); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AlternationPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_alternation_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AndNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_and_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_array_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_array_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_assoc_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocSplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_assoc_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BackReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_back_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BeginNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_begin_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockArgumentNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_block_argument_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockLocalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_block_local_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_block_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_block_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_block_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BreakNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_break_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_call_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_call_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_call_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_call_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_call_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CapturePatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_capture_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseMatchNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_case_match_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_case_node(node); end
+
+  # Visit the child nodes of the given node.
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_child_nodes(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_class_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_path_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_constant_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_def_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefinedNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_defined_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ElseNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_else_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedStatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_embedded_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_embedded_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EnsureNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_ensure_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FalseNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_false_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FindPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_find_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FlipFlopNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_flip_flop_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FloatNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_float_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_for_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingSuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_forwarding_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_global_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_hash_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IfNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_if_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImaginaryNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_imaginary_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_implicit_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitRestNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_implicit_rest_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_in_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_index_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_index_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_index_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_index_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_instance_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IntegerNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_integer_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedMatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedRegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_interpolated_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedSymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedXStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordHashNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_keyword_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordRestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LambdaNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_lambda_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_local_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchPredicateNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_match_predicate_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchRequiredNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_match_required_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_match_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MissingNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_missing_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ModuleNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_module_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_multi_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_multi_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NextNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_next_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NilNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_nil_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NoKeywordsParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_numbered_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_optional_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OrNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_or_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParenthesesNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_parentheses_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_pinned_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_pinned_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PostExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_post_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PreExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_pre_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ProgramNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_program_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RangeNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_range_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RationalNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_rational_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RedoNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_redo_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_required_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueModifierNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_rescue_modifier_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_rescue_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RetryNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_retry_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ReturnNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_return_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SelfNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_self_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SingletonClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_singleton_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceEncodingNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_source_encoding_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceFileNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_source_file_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_source_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StringNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a TrueNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_true_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UndefNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_undef_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UnlessNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_unless_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UntilNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_until_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhenNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_when_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhileNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_while_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a XStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a YieldNode node
+  #
+  # source://prism-0.20.0/lib/prism/compiler.rb:38
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant.
+#
+#     Target &&= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4102
+class Prism::ConstantAndWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4115
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4124
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4129
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4139
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4134
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4144
+  sig { params(params: T.untyped).returns(Prism::ConstantAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4129
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4158
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4168
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4103
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4106
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4163
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4109
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4192
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4112
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4202
+    def type; end
+  end
+end
+
+# Represents assigning to a constant using an operator that isn't `=`.
+#
+#     Target += value
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4212
+class Prism::ConstantOperatorWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+  #
+  # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4228
+  def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4238
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4243
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4253
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4248
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4258
+  sig { params(params: T.untyped).returns(Prism::ConstantOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4243
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4273
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4278
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4213
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4216
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4225
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4219
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4303
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4222
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4313
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant.
+#
+#     Target ||= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4323
+class Prism::ConstantOrWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4336
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4345
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4350
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4360
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4355
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4365
+  sig { params(params: T.untyped).returns(Prism::ConstantOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4350
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4379
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4389
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4324
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4327
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4384
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4330
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4413
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4333
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4423
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant path.
+#
+#     Parent::Child &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4433
+class Prism::ConstantPathAndWriteNode < ::Prism::Node
+  # def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4443
+  def initialize(target, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4451
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4466
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4461
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4471
+  sig { params(params: T.untyped).returns(Prism::ConstantPathAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4484
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4494
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4489
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4437
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4434
+  sig { returns(Prism::ConstantPathNode) }
+  def target; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4518
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4440
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4528
+    def type; end
+  end
+end
+
+# Represents accessing a constant through a path of `::` operators.
+#
+#     Foo::Bar
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4538
+class Prism::ConstantPathNode < ::Prism::Node
+  # def initialize: (Node? parent, Node child, Location delimiter_loc, Location location) -> void
+  #
+  # @return [ConstantPathNode] a new instance of ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4548
+  def initialize(parent, child, delimiter_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4556
+  def accept(visitor); end
+
+  # attr_reader child: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4542
+  sig { returns(Prism::Node) }
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4561
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4574
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4566
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4579
+  sig { params(params: T.untyped).returns(Prism::ConstantPathNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4561
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Node?, child: Node, delimiter_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4592
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4597
+  sig { returns(String) }
+  def delimiter; end
+
+  # attr_reader delimiter_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4545
+  sig { returns(Prism::Location) }
+  def delimiter_loc; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:129
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:112
+  def full_name_parts; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4602
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader parent: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4539
+  sig { returns(T.nilable(Prism::Node)) }
+  def parent; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4630
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4640
+    def type; end
+  end
+end
+
+# An error class raised when dynamic parts are found while computing a
+# constant path's full name. For example:
+# Foo::Bar::Baz -> does not raise because all parts of the constant path are
+# simple constants
+# var::Bar::Baz -> raises because the first part of the constant path is a
+# local variable
+#
+# source://prism-0.20.0/lib/prism/node_ext.rb:108
+class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
+
+# Represents assigning to a constant path using an operator that isn't `=`.
+#
+#     Parent::Child += value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4650
+class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
+  # def initialize: (ConstantPathNode target, Location operator_loc, Node value, Symbol operator, Location location) -> void
+  #
+  # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4663
+  def initialize(target, operator_loc, value, operator, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4672
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4677
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4687
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4682
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4692
+  sig { params(params: T.untyped).returns(Prism::ConstantPathOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4677
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4706
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4711
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4660
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4654
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4651
+  sig { returns(Prism::ConstantPathNode) }
+  def target; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4736
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4657
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4746
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant path.
+#
+#     Parent::Child ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4756
+class Prism::ConstantPathOrWriteNode < ::Prism::Node
+  # def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4766
+  def initialize(target, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4774
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4779
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4789
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4784
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4794
+  sig { params(params: T.untyped).returns(Prism::ConstantPathOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4779
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4807
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4817
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4812
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4760
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4757
+  sig { returns(Prism::ConstantPathNode) }
+  def target; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4841
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4763
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4851
+    def type; end
+  end
+end
+
+# Represents writing to a constant path in a context that doesn't have an explicit value.
+#
+#     Foo::Foo, Bar::Bar = baz
+#     ^^^^^^^^  ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4861
+class Prism::ConstantPathTargetNode < ::Prism::Node
+  # def initialize: (Node? parent, Node child, Location delimiter_loc, Location location) -> void
+  #
+  # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4871
+  def initialize(parent, child, delimiter_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4879
+  def accept(visitor); end
+
+  # attr_reader child: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4865
+  sig { returns(Prism::Node) }
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4884
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4897
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4889
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4902
+  sig { params(params: T.untyped).returns(Prism::ConstantPathTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4884
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Node?, child: Node, delimiter_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4915
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4920
+  sig { returns(String) }
+  def delimiter; end
+
+  # attr_reader delimiter_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4868
+  sig { returns(Prism::Location) }
+  def delimiter_loc; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:142
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:137
+  def full_name_parts; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4925
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader parent: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4862
+  sig { returns(T.nilable(Prism::Node)) }
+  def parent; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4953
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:4963
+    def type; end
+  end
+end
+
+# Represents writing to a constant path.
+#
+#     ::Foo = 1
+#     ^^^^^^^^^
+#
+#     Foo::Bar = 1
+#     ^^^^^^^^^^^^
+#
+#     ::Foo::Bar = 1
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:4979
+class Prism::ConstantPathWriteNode < ::Prism::Node
+  # def initialize: (ConstantPathNode target, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4989
+  def initialize(target, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4997
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5002
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5012
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5007
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantPathWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5017
+  sig { params(params: T.untyped).returns(Prism::ConstantPathWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5002
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5030
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5040
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5035
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4983
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4980
+  sig { returns(Prism::ConstantPathNode) }
+  def target; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5064
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:4986
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5074
+    def type; end
+  end
+end
+
+# Represents referencing a constant.
+#
+#     Foo
+#     ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5088
+class Prism::ConstantReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [ConstantReadNode] a new instance of ConstantReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5092
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5098
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5103
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5113
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5108
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5118
+  sig { params(params: T.untyped).returns(Prism::ConstantReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5103
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5129
+  def deconstruct_keys(keys); end
+
+  # Returns the full name of this constant. For example: "Foo"
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:96
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:91
+  def full_name_parts; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5134
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # 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`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5089
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5154
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5164
+    def type; end
+  end
+end
+
+# Represents writing to a constant in a context that doesn't have an explicit value.
+#
+#     Foo, Bar = baz
+#     ^^^  ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5174
+class Prism::ConstantTargetNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [ConstantTargetNode] a new instance of ConstantTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5178
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5184
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5189
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5199
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5194
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5204
+  sig { params(params: T.untyped).returns(Prism::ConstantTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5189
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5215
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5220
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5175
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5240
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5250
+    def type; end
+  end
+end
+
+# Represents writing to a constant.
+#
+#     Foo = 1
+#     ^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5260
+class Prism::ConstantWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+  #
+  # @return [ConstantWriteNode] a new instance of ConstantWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5273
+  def initialize(name, name_loc, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5282
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5287
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5297
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5292
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ConstantWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5302
+  sig { params(params: T.untyped).returns(Prism::ConstantWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5287
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5316
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5326
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5261
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5264
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5321
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5270
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5350
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5267
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5360
+    def type; end
+  end
+end
+
+class Prism::DATAComment < Prism::Comment; end
+
+# The DSL module provides a set of methods that can be used to create prism
+# nodes in a more concise manner. For example, instead of writing:
+#
+#     source = Prism::Source.new("[1]")
+#
+#     Prism::ArrayNode.new(
+#       [
+#         Prism::IntegerNode.new(
+#           Prism::IntegerBaseFlags::DECIMAL,
+#           Prism::Location.new(source, 1, 1),
+#         )
+#       ],
+#       Prism::Location.new(source, 0, 1),
+#       Prism::Location.new(source, 2, 1)
+#     )
+#
+# you could instead write:
+#
+#     source = Prism::Source.new("[1]")
+#
+#     ArrayNode(
+#       IntegerNode(Prism::IntegerBaseFlags::DECIMAL, Location(source, 1, 1))),
+#       Location(source, 0, 1),
+#       Location(source, 2, 1)
+#     )
+#
+# This is mostly helpful in the context of writing tests, but can also be used
+# to generate trees programmatically.
+#
+# source://prism-0.20.0/lib/prism/dsl.rb:37
+module Prism::DSL
+  private
+
+  # Create a new AliasGlobalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:46
+  def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new AliasMethodNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:51
+  def AliasMethodNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new AlternationPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:56
+  def AlternationPatternNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new AndNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:61
+  def AndNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new ArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:66
+  def ArgumentsNode(flags, arguments, location = T.unsafe(nil)); end
+
+  # Create a new ArrayNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:71
+  def ArrayNode(flags, elements, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new ArrayPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:76
+  def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new AssocNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:81
+  def AssocNode(key, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new AssocSplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:86
+  def AssocSplatNode(value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new BackReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:91
+  def BackReferenceReadNode(name, location = T.unsafe(nil)); end
+
+  # Create a new BeginNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:96
+  def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new BlockArgumentNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:101
+  def BlockArgumentNode(expression, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new BlockLocalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:106
+  def BlockLocalVariableNode(flags, name, location = T.unsafe(nil)); end
+
+  # Create a new BlockNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:111
+  def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new BlockParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:116
+  def BlockParameterNode(flags, name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new BlockParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:121
+  def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new BreakNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:126
+  def BreakNode(arguments, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new CallAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:131
+  def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new CallNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:136
+  def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location = T.unsafe(nil)); end
+
+  # Create a new CallOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:141
+  def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new CallOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:146
+  def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new CallTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:151
+  def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = T.unsafe(nil)); end
+
+  # Create a new CapturePatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:156
+  def CapturePatternNode(value, target, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new CaseMatchNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:161
+  def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new CaseNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:166
+  def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new ClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:171
+  def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:176
+  def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:181
+  def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:186
+  def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:191
+  def ClassVariableReadNode(name, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:196
+  def ClassVariableTargetNode(name, location = T.unsafe(nil)); end
+
+  # Create a new ClassVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:201
+  def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new ConstantAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:206
+  def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ConstantOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:211
+  def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+  # Create a new ConstantOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:216
+  def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:221
+  def ConstantPathAndWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:226
+  def ConstantPathNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:231
+  def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:236
+  def ConstantPathOrWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:241
+  def ConstantPathTargetNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end
+
+  # Create a new ConstantPathWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:246
+  def ConstantPathWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new ConstantReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:251
+  def ConstantReadNode(name, location = T.unsafe(nil)); end
+
+  # Create a new ConstantTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:256
+  def ConstantTargetNode(name, location = T.unsafe(nil)); end
+
+  # Create a new ConstantWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:261
+  def ConstantWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new DefNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:266
+  def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new DefinedNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:271
+  def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new ElseNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:276
+  def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new EmbeddedStatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:281
+  def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new EmbeddedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:286
+  def EmbeddedVariableNode(operator_loc, variable, location = T.unsafe(nil)); end
+
+  # Create a new EnsureNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:291
+  def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new FalseNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:296
+  def FalseNode(location = T.unsafe(nil)); end
+
+  # Create a new FindPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:301
+  def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new FlipFlopNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:306
+  def FlipFlopNode(flags, left, right, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new FloatNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:311
+  def FloatNode(location = T.unsafe(nil)); end
+
+  # Create a new ForNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:316
+  def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new ForwardingArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:321
+  def ForwardingArgumentsNode(location = T.unsafe(nil)); end
+
+  # Create a new ForwardingParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:326
+  def ForwardingParameterNode(location = T.unsafe(nil)); end
+
+  # Create a new ForwardingSuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:331
+  def ForwardingSuperNode(block, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:336
+  def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:341
+  def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:346
+  def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:351
+  def GlobalVariableReadNode(name, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:356
+  def GlobalVariableTargetNode(name, location = T.unsafe(nil)); end
+
+  # Create a new GlobalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:361
+  def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new HashNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:366
+  def HashNode(opening_loc, elements, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new HashPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:371
+  def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new IfNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:376
+  def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new ImaginaryNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:381
+  def ImaginaryNode(numeric, location = T.unsafe(nil)); end
+
+  # Create a new ImplicitNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:386
+  def ImplicitNode(value, location = T.unsafe(nil)); end
+
+  # Create a new ImplicitRestNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:391
+  def ImplicitRestNode(location = T.unsafe(nil)); end
+
+  # Create a new InNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:396
+  def InNode(pattern, statements, in_loc, then_loc, location = T.unsafe(nil)); end
+
+  # Create a new IndexAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:401
+  def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new IndexOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:406
+  def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new IndexOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:411
+  def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new IndexTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:416
+  def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:421
+  def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:426
+  def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:431
+  def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:436
+  def InstanceVariableReadNode(name, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:441
+  def InstanceVariableTargetNode(name, location = T.unsafe(nil)); end
+
+  # Create a new InstanceVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:446
+  def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new IntegerNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:451
+  def IntegerNode(flags, location = T.unsafe(nil)); end
+
+  # Create a new InterpolatedMatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:456
+  def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new InterpolatedRegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:461
+  def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new InterpolatedStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:466
+  def InterpolatedStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new InterpolatedSymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:471
+  def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new InterpolatedXStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:476
+  def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new KeywordHashNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:481
+  def KeywordHashNode(flags, elements, location = T.unsafe(nil)); end
+
+  # Create a new KeywordRestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:486
+  def KeywordRestParameterNode(flags, name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new LambdaNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:491
+  def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:496
+  def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:501
+  def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:506
+  def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:511
+  def LocalVariableReadNode(name, depth, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:516
+  def LocalVariableTargetNode(name, depth, location = T.unsafe(nil)); end
+
+  # Create a new LocalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:521
+  def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new Location object
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:41
+  def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end
+
+  # Create a new MatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:526
+  def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+  # Create a new MatchPredicateNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:531
+  def MatchPredicateNode(value, pattern, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new MatchRequiredNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:536
+  def MatchRequiredNode(value, pattern, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new MatchWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:541
+  def MatchWriteNode(call, targets, location = T.unsafe(nil)); end
+
+  # Create a new MissingNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:546
+  def MissingNode(location = T.unsafe(nil)); end
+
+  # Create a new ModuleNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:551
+  def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = T.unsafe(nil)); end
+
+  # Create a new MultiTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:556
+  def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = T.unsafe(nil)); end
+
+  # Create a new MultiWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:561
+  def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new NextNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:566
+  def NextNode(arguments, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new NilNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:571
+  def NilNode(location = T.unsafe(nil)); end
+
+  # Create a new NoKeywordsParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:576
+  def NoKeywordsParameterNode(operator_loc, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new NumberedParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:581
+  def NumberedParametersNode(maximum, location = T.unsafe(nil)); end
+
+  # Create a new NumberedReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:586
+  def NumberedReferenceReadNode(number, location = T.unsafe(nil)); end
+
+  # Create a new OptionalKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:591
+  def OptionalKeywordParameterNode(flags, name, name_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new OptionalParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:596
+  def OptionalParameterNode(flags, name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+  # Create a new OrNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:601
+  def OrNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new ParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:606
+  def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = T.unsafe(nil)); end
+
+  # Create a new ParenthesesNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:611
+  def ParenthesesNode(body, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new PinnedExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:616
+  def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = T.unsafe(nil)); end
+
+  # Create a new PinnedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:621
+  def PinnedVariableNode(variable, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new PostExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:626
+  def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new PreExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:631
+  def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+  # Create a new ProgramNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:636
+  def ProgramNode(locals, statements, location = T.unsafe(nil)); end
+
+  # Create a new RangeNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:641
+  def RangeNode(flags, left, right, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new RationalNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:646
+  def RationalNode(numeric, location = T.unsafe(nil)); end
+
+  # Create a new RedoNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:651
+  def RedoNode(location = T.unsafe(nil)); end
+
+  # Create a new RegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:656
+  def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+  # Create a new RequiredKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:661
+  def RequiredKeywordParameterNode(flags, name, name_loc, location = T.unsafe(nil)); end
+
+  # Create a new RequiredParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:666
+  def RequiredParameterNode(flags, name, location = T.unsafe(nil)); end
+
+  # Create a new RescueModifierNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:671
+  def RescueModifierNode(expression, keyword_loc, rescue_expression, location = T.unsafe(nil)); end
+
+  # Create a new RescueNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:676
+  def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = T.unsafe(nil)); end
+
+  # Create a new RestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:681
+  def RestParameterNode(flags, name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+  # Create a new RetryNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:686
+  def RetryNode(location = T.unsafe(nil)); end
+
+  # Create a new ReturnNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:691
+  def ReturnNode(keyword_loc, arguments, location = T.unsafe(nil)); end
+
+  # Create a new SelfNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:696
+  def SelfNode(location = T.unsafe(nil)); end
+
+  # Create a new SingletonClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:701
+  def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new SourceEncodingNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:706
+  def SourceEncodingNode(location = T.unsafe(nil)); end
+
+  # Create a new SourceFileNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:711
+  def SourceFileNode(filepath, location = T.unsafe(nil)); end
+
+  # Create a new SourceLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:716
+  def SourceLineNode(location = T.unsafe(nil)); end
+
+  # Create a new SplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:721
+  def SplatNode(operator_loc, expression, location = T.unsafe(nil)); end
+
+  # Create a new StatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:726
+  def StatementsNode(body, location = T.unsafe(nil)); end
+
+  # Create a new StringNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:731
+  def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+  # Create a new SuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:736
+  def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = T.unsafe(nil)); end
+
+  # Create a new SymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:741
+  def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+  # Create a new TrueNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:746
+  def TrueNode(location = T.unsafe(nil)); end
+
+  # Create a new UndefNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:751
+  def UndefNode(names, keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new UnlessNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:756
+  def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end
+
+  # Create a new UntilNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:761
+  def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location = T.unsafe(nil)); end
+
+  # Create a new WhenNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:766
+  def WhenNode(keyword_loc, conditions, statements, location = T.unsafe(nil)); end
+
+  # Create a new WhileNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:771
+  def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location = T.unsafe(nil)); end
+
+  # Create a new XStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:776
+  def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+  # Create a new YieldNode node
+  #
+  # source://prism-0.20.0/lib/prism/dsl.rb:781
+  def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = T.unsafe(nil)); end
+end
+
+# This module is used for testing and debugging and is not meant to be used by
+# consumers of this library.
+#
+# source://prism-0.20.0/lib/prism/debug.rb:6
+module Prism::Debug
+  class << self
+    # :call-seq:
+    #   Debug::cruby_locals(source) -> Array
+    #
+    # For the given source, compiles with CRuby and returns a list of all of the
+    # sets of local variables that were encountered.
+    #
+    # source://prism-0.20.0/lib/prism/debug.rb:54
+    def cruby_locals(source); end
+
+    def format_errors(_arg0, _arg1); end
+    def inspect_node(_arg0); end
+    def memsize(_arg0); end
+    def named_captures(_arg0); end
+
+    # :call-seq:
+    #   Debug::newlines(source) -> Array
+    #
+    # For the given source string, return the byte offsets of every newline in
+    # the source.
+    #
+    # source://prism-0.20.0/lib/prism/debug.rb:202
+    def newlines(source); end
+
+    # :call-seq:
+    #   Debug::prism_locals(source) -> Array
+    #
+    # For the given source, parses with prism and returns a list of all of the
+    # sets of local variables that were encountered.
+    #
+    # source://prism-0.20.0/lib/prism/debug.rb:98
+    def prism_locals(source); end
+
+    def profile_file(_arg0); end
+  end
+end
+
+# Used to hold the place of a local that will be in the local table but
+# cannot be accessed directly from the source code. For example, the
+# iteration variable in a for loop or the positional parameter on a method
+# definition that is destructured.
+#
+# source://prism-0.20.0/lib/prism/debug.rb:90
+Prism::Debug::AnonymousLocal = T.let(T.unsafe(nil), Object)
+
+# A wrapper around a RubyVM::InstructionSequence that provides a more
+# convenient interface for accessing parts of the iseq.
+#
+# source://prism-0.20.0/lib/prism/debug.rb:9
+class Prism::Debug::ISeq
+  # @return [ISeq] a new instance of ISeq
+  #
+  # source://prism-0.20.0/lib/prism/debug.rb:12
+  def initialize(parts); end
+
+  # source://prism-0.20.0/lib/prism/debug.rb:28
+  def each_child; end
+
+  # source://prism-0.20.0/lib/prism/debug.rb:24
+  def instructions; end
+
+  # source://prism-0.20.0/lib/prism/debug.rb:20
+  def local_table; end
+
+  # source://prism-0.20.0/lib/prism/debug.rb:10
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/debug.rb:16
+  def type; end
+end
+
+# Represents a method definition.
+#
+#     def method
+#     end
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5371
+class Prism::DefNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Node? receiver, ParametersNode? parameters, Node? body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc, Location location) -> void
+  #
+  # @return [DefNode] a new instance of DefNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5408
+  def initialize(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5425
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5384
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5430
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5444
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5435
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> DefNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5449
+  sig { params(params: T.untyped).returns(Prism::DefNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5430
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5471
+  def deconstruct_keys(keys); end
+
+  # def def_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5476
+  sig { returns(String) }
+  def def_keyword; end
+
+  # attr_reader def_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5390
+  sig { returns(Prism::Location) }
+  def def_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5501
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5405
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # def equal: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5496
+  sig { returns(T.nilable(String)) }
+  def equal; end
+
+  # attr_reader equal_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5402
+  sig { returns(T.nilable(Prism::Location)) }
+  def equal_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5506
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5387
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5486
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5396
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5372
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5375
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5481
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5393
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5381
+  sig { returns(T.nilable(Prism::ParametersNode)) }
+  def parameters; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5378
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5491
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5399
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5552
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5562
+    def type; end
+  end
+end
+
+# Represents the use of the `defined?` keyword.
+#
+#     defined?(a)
+#     ^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5572
+class Prism::DefinedNode < ::Prism::Node
+  # def initialize: (Location? lparen_loc, Node value, Location? rparen_loc, Location keyword_loc, Location location) -> void
+  #
+  # @return [DefinedNode] a new instance of DefinedNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5585
+  def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5594
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5599
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5609
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5604
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> DefinedNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5614
+  sig { params(params: T.untyped).returns(Prism::DefinedNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5599
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5628
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5648
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5643
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5582
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5633
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5573
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5638
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5579
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5672
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5576
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5682
+    def type; end
+  end
+end
+
+# DesugarCompiler is a compiler that desugars Ruby code into a more primitive
+# form. This is useful for consumers that want to deal with fewer node types.
+#
+# source://prism-0.20.0/lib/prism/desugar_compiler.rb:11
+class Prism::DesugarCompiler < ::Prism::MutationCompiler
+  # @@foo &&= bar
+  #
+  # becomes
+  #
+  # @@foo && @@foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:12
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  #
+  # becomes
+  #
+  # @@foo = @@foo + bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:30
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(@@foo) ? @@foo : @@foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:21
+  def visit_class_variable_or_write_node(node); end
+
+  # Foo &&= bar
+  #
+  # becomes
+  #
+  # Foo && Foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:39
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  #
+  # becomes
+  #
+  # Foo = Foo + bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:57
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(Foo) ? Foo : Foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:48
+  def visit_constant_or_write_node(node); end
+
+  # $foo &&= bar
+  #
+  # becomes
+  #
+  # $foo && $foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:66
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  #
+  # becomes
+  #
+  # $foo = $foo + bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:84
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  #
+  # becomes
+  #
+  # defined?($foo) ? $foo : $foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:75
+  def visit_global_variable_or_write_node(node); end
+
+  # becomes
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:93
+  def visit_instance_variable_and_write_node(node); end
+
+  # becomes
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:111
+  def visit_instance_variable_operator_write_node(node); end
+
+  # becomes
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:102
+  def visit_instance_variable_or_write_node(node); end
+
+  # foo &&= bar
+  #
+  # becomes
+  #
+  # foo && foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:120
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  #
+  # becomes
+  #
+  # foo = foo + bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:138
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  #
+  # becomes
+  #
+  # foo || foo = bar
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:129
+  def visit_local_variable_or_write_node(node); end
+
+  private
+
+  # Desugar `x &&= y` to `x && x = y`
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:145
+  def desugar_and_write_node(node, read_class, write_class, *arguments); end
+
+  # Desugar `x += y` to `x = x + y`
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:155
+  def desugar_operator_write_node(node, read_class, write_class, *arguments); end
+
+  # Desugar `x ||= y` to `defined?(x) ? x : x = y`
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:187
+  def desugar_or_write_defined_node(node, read_class, write_class, *arguments); end
+
+  # Desugar `x ||= y` to `x || x = y`
+  #
+  # source://prism-0.20.0/lib/prism/desugar_compiler.rb:177
+  def desugar_or_write_node(node, read_class, write_class, *arguments); end
+end
+
+# The dispatcher class fires events for nodes that are found while walking an
+# AST to all registered listeners. It's useful for performing different types
+# of analysis on the AST while only having to walk the tree once.
+#
+# To use the dispatcher, you would first instantiate it and register listeners
+# for the events you're interested in:
+#
+#     class OctalListener
+#       def on_integer_node_enter(node)
+#         if node.octal? && !node.slice.start_with?("0o")
+#           warn("Octal integers should be written with the 0o prefix")
+#         end
+#       end
+#     end
+#
+#     dispatcher = Dispatcher.new
+#     dispatcher.register(listener, :on_integer_node_enter)
+#
+# Then, you can walk any number of trees and dispatch events to the listeners:
+#
+#     result = Prism.parse("001 + 002 + 003")
+#     dispatcher.dispatch(result.value)
+#
+# Optionally, you can also use `#dispatch_once` to dispatch enter and leave
+# events for a single node without recursing further down the tree. This can
+# be useful in circumstances where you want to reuse the listeners you already
+# have registers but want to stop walking the tree at a certain point.
+#
+#     integer = result.value.statements.body.first.receiver.receiver
+#     dispatcher.dispatch_once(integer)
+#
+# source://prism-0.20.0/lib/prism/dispatcher.rb:41
+class Prism::Dispatcher < ::Prism::Visitor
+  # Initialize a new dispatcher.
+  #
+  # @return [Dispatcher] a new instance of Dispatcher
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:45
+  def initialize; end
+
+  # Walks `root` dispatching events to all registered listeners.
+  #
+  # def dispatch: (Node) -> void
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:16
+  def dispatch(node); end
+
+  # Dispatches a single event for `node` to all registered listeners.
+  #
+  # def dispatch_once: (Node) -> void
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:64
+  def dispatch_once(node); end
+
+  # attr_reader listeners: Hash[Symbol, Array[Listener]]
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:42
+  def listeners; end
+
+  # Register a listener for one or more events.
+  #
+  # def register: (Listener, *Symbol) -> void
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:52
+  def register(listener, *events); end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:70
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:78
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:86
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:94
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:102
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:110
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:118
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:126
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:134
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:142
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:150
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:158
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:166
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:174
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:182
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:190
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:198
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:206
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:214
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:222
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:230
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:238
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:246
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:254
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:262
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:270
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:278
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:286
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:294
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:302
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:310
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:318
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:326
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:334
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:342
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:350
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:358
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:366
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:374
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:382
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:390
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:398
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:406
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:414
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:422
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:430
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:438
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:446
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:454
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:462
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:470
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:478
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:486
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:494
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:502
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:510
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:518
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:526
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:534
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:542
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:550
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:558
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:566
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:574
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:582
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:590
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:598
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:606
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:614
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:622
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:630
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:638
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:646
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:654
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:662
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:670
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:678
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:686
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:694
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:702
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:710
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:718
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:726
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:734
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:742
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:750
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:758
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:766
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:774
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:782
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:790
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:798
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:806
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:814
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:822
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:830
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:838
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:846
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:854
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:862
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:870
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:878
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:886
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:894
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:902
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:910
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:918
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:926
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:934
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:942
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:950
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:958
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:966
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:974
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:982
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:990
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:998
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1006
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1014
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1022
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1030
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1038
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1046
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1054
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1062
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1070
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1078
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1086
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1094
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1102
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1110
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1118
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1126
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1134
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1142
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1150
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1158
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1166
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1174
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1182
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1190
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1198
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1206
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1214
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1222
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1230
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1238
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes and continue
+  # walking the tree.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1246
+  def visit_yield_node(node); end
+end
+
+# source://prism-0.20.0/lib/prism/dispatcher.rb:1252
+class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
+  # @return [DispatchOnce] a new instance of DispatchOnce
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1255
+  def initialize(listeners); end
+
+  # Returns the value of attribute listeners.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1253
+  def listeners; end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1260
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1266
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1272
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1278
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1284
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1290
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1296
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1302
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1308
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1314
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1320
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1326
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1332
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1338
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1344
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1350
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1356
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1362
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1368
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1374
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1380
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1386
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1392
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1398
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1404
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1410
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1416
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1422
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1428
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1434
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1440
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1446
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1452
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1458
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1464
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1470
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1476
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1482
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1488
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1494
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1500
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1506
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1512
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1518
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1524
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1530
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1536
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1542
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1548
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1554
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1560
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1566
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1572
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1578
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1584
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1590
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1596
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1602
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1608
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1614
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1620
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1626
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1632
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1638
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1644
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1650
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1656
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1662
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1668
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1674
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1680
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1686
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1692
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1698
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1704
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1710
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1716
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1722
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1728
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1734
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1740
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1746
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1752
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1758
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1764
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1770
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1776
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1782
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1788
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1794
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1800
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1806
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1812
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1818
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1824
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1830
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1836
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1842
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1848
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1854
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1860
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1866
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1872
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1878
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1884
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1890
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1896
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1902
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1908
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1914
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1920
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1926
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1932
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1938
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1944
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1950
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1956
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1962
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1968
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1974
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1980
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1986
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1992
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:1998
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2004
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2010
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2016
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2022
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2028
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2034
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2040
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2046
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2052
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2058
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2064
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2070
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2076
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2082
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2088
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2094
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2100
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2106
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2112
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2118
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2124
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2130
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2136
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dispatcher.rb:2142
+  def visit_yield_node(node); end
+end
+
+# This visitor provides the ability to call Node#to_dot, which converts a
+# subtree into a graphviz dot graph.
+#
+# source://prism-0.20.0/lib/prism/dot_visitor.rb:13
+class Prism::DotVisitor < ::Prism::Visitor
+  # Initialize a new dot visitor.
+  #
+  # @return [DotVisitor] a new instance of DotVisitor
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:105
+  def initialize; end
+
+  # The digraph that is being built.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:102
+  def digraph; end
+
+  # Convert this visitor into a graphviz dot graph string.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:110
+  def to_dot; end
+
+  # Visit a AliasGlobalVariableNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:115
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:140
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:165
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:190
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:215
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:245
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:285
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:347
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:374
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:397
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:414
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:462
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:485
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:505
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:540
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:568
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:611
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:634
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:680
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:738
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:787
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:833
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:863
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:888
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:933
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:978
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1025
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1052
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1082
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1109
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1126
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1143
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1172
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1199
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1229
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1256
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1281
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1308
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1336
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1361
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1388
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1413
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1430
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1447
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1474
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1543
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1574
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1602
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1628
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1649
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1675
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1689
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1740
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1772
+  def visit_float_node(node); end
+
+  # Visit a ForNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1786
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1828
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1842
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1856
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1876
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1903
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1933
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1960
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1977
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:1994
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2021
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2054
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2103
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2148
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2166
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2184
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2198
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2230
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2283
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2339
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2392
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2431
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2458
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2488
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2515
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2532
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2549
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2576
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2593
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2629
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2665
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2702
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2739
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a KeywordHashNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2772
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2802
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2830
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2868
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2898
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2931
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2961
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:2981
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3001
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3031
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3060
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3085
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3110
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3141
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3155
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3191
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3247
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3310
+  def visit_next_node(node); end
+
+  # Visit a NilNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3333
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3347
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3367
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3384
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3401
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3428
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3458
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3483
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3567
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3593
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3620
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3641
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3670
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3699
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3720
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3752
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3770
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3784
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3813
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3836
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3856
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3881
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3934
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3962
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3976
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:3999
+  def visit_self_node(node); end
+
+  # Visit a SingletonClassNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4013
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4049
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4063
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4080
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4094
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4117
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4144
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4177
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4216
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4251
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4265
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4295
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4338
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4373
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4409
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4444
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4473
+  def visit_yield_node(node); end
+
+  private
+
+  # Inspect a node that has arguments_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4519
+  def arguments_node_flags_inspect(node); end
+
+  # Inspect a node that has array_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4527
+  def array_node_flags_inspect(node); end
+
+  # Inspect a node that has call_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4535
+  def call_node_flags_inspect(node); end
+
+  # Inspect a node that has encoding_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4546
+  def encoding_flags_inspect(node); end
+
+  # Inspect a node that has integer_base_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4555
+  def integer_base_flags_inspect(node); end
+
+  # Inspect a node that has keyword_hash_node_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4566
+  def keyword_hash_node_flags_inspect(node); end
+
+  # Inspect a location to display the start and end line and column numbers.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4513
+  def location_inspect(location); end
+
+  # Inspect a node that has loop_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4574
+  def loop_flags_inspect(node); end
+
+  # Generate a unique node ID for a node throughout the digraph.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4508
+  def node_id(node); end
+
+  # Inspect a node that has parameter_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4582
+  def parameter_flags_inspect(node); end
+
+  # Inspect a node that has range_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4590
+  def range_flags_inspect(node); end
+
+  # Inspect a node that has regular_expression_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4598
+  def regular_expression_flags_inspect(node); end
+
+  # Inspect a node that has string_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4616
+  def string_flags_inspect(node); end
+
+  # Inspect a node that has symbol_flags flags to display the flags as a
+  # comma-separated list.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:4626
+  def symbol_flags_inspect(node); end
+end
+
+# source://prism-0.20.0/lib/prism/dot_visitor.rb:58
+class Prism::DotVisitor::Digraph
+  # @return [Digraph] a new instance of Digraph
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:61
+  def initialize; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:75
+  def edge(value); end
+
+  # Returns the value of attribute edges.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:59
+  def edges; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:67
+  def node(value); end
+
+  # Returns the value of attribute nodes.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:59
+  def nodes; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:79
+  def to_dot; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:71
+  def waypoint(value); end
+
+  # Returns the value of attribute waypoints.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:59
+  def waypoints; end
+end
+
+# source://prism-0.20.0/lib/prism/dot_visitor.rb:14
+class Prism::DotVisitor::Field
+  # @return [Field] a new instance of Field
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:17
+  def initialize(name, value, port); end
+
+  # Returns the value of attribute name.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:15
+  def name; end
+
+  # Returns the value of attribute port.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:15
+  def port; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:23
+  def to_dot; end
+
+  # Returns the value of attribute value.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:15
+  def value; end
+end
+
+# source://prism-0.20.0/lib/prism/dot_visitor.rb:32
+class Prism::DotVisitor::Table
+  # @return [Table] a new instance of Table
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:35
+  def initialize(name); end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:40
+  def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
+
+  # Returns the value of attribute fields.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:33
+  def fields; end
+
+  # Returns the value of attribute name.
+  #
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:33
+  def name; end
+
+  # source://prism-0.20.0/lib/prism/dot_visitor.rb:44
+  def to_dot; end
+end
+
+# Represents an `else` clause in a `case`, `if`, or `unless` statement.
+#
+#     if a then b else c end
+#                 ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5692
+class Prism::ElseNode < ::Prism::Node
+  # def initialize: (Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc, Location location) -> void
+  #
+  # @return [ElseNode] a new instance of ElseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5702
+  def initialize(else_keyword_loc, statements, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5710
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5715
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5727
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5720
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ElseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5732
+  sig { params(params: T.untyped).returns(Prism::ElseNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5715
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5745
+  def deconstruct_keys(keys); end
+
+  # def else_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5750
+  sig { returns(String) }
+  def else_keyword; end
+
+  # attr_reader else_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5693
+  sig { returns(Prism::Location) }
+  def else_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5755
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5699
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5760
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5696
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5787
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5797
+    def type; end
+  end
+end
+
+# EmbDocComment objects correspond to comments that are surrounded by =begin
+# and =end.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:261
+class Prism::EmbDocComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:267
+  def inspect; end
+
+  # This can only be true for inline comments.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:262
+  def trailing?; end
+end
+
+# Represents an interpolated set of statements.
+#
+#     "foo #{bar}"
+#          ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5807
+class Prism::EmbeddedStatementsNode < ::Prism::Node
+  # def initialize: (Location opening_loc, StatementsNode? statements, Location closing_loc, Location location) -> void
+  #
+  # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5817
+  def initialize(opening_loc, statements, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5825
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5830
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5870
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5814
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5842
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5835
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> EmbeddedStatementsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5847
+  sig { params(params: T.untyped).returns(Prism::EmbeddedStatementsNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5830
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5860
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5875
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5865
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5808
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5811
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5902
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:5912
+    def type; end
+  end
+end
+
+# Represents an interpolated variable.
+#
+#     "foo #@bar"
+#          ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:5922
+class Prism::EmbeddedVariableNode < ::Prism::Node
+  # def initialize: (Location operator_loc, Node variable, Location location) -> void
+  #
+  # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5929
+  def initialize(operator_loc, variable, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5936
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5941
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5951
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5946
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> EmbeddedVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5956
+  sig { params(params: T.untyped).returns(Prism::EmbeddedVariableNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5941
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, variable: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5968
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5978
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5973
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5923
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6000
+  def type; end
+
+  # attr_reader variable: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:5926
+  sig { returns(Prism::Node) }
+  def variable; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6010
+    def type; end
+  end
+end
+
+# Flags for nodes that have unescaped content.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17578
+module Prism::EncodingFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism-0.20.0/lib/prism/node.rb:17583
+Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism-0.20.0/lib/prism/node.rb:17580
+Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# Represents an `ensure` clause in a `begin` statement.
+#
+#     begin
+#       foo
+#     ensure
+#     ^^^^^^
+#       bar
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:6024
+class Prism::EnsureNode < ::Prism::Node
+  # def initialize: (Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc, Location location) -> void
+  #
+  # @return [EnsureNode] a new instance of EnsureNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6034
+  def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6042
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6047
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6059
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6052
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> EnsureNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6064
+  sig { params(params: T.untyped).returns(Prism::EnsureNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6047
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6077
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6087
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6031
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def ensure_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6082
+  sig { returns(String) }
+  def ensure_keyword; end
+
+  # attr_reader ensure_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6025
+  sig { returns(Prism::Location) }
+  def ensure_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6092
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6028
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6119
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6129
+    def type; end
+  end
+end
+
+# Represents the use of the literal `false` keyword.
+#
+#     false
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6139
+class Prism::FalseNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [FalseNode] a new instance of FalseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6140
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6145
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6150
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6160
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6155
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> FalseNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6165
+  sig { params(params: T.untyped).returns(Prism::FalseNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6150
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6175
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6180
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6199
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6209
+    def type; end
+  end
+end
+
+# Represents a find pattern in pattern matching.
+#
+#     foo in *bar, baz, *qux
+#            ^^^^^^^^^^^^^^^
+#
+#     foo in [*bar, baz, *qux]
+#            ^^^^^^^^^^^^^^^^^
+#
+#     foo in Foo(*bar, baz, *qux)
+#            ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6225
+class Prism::FindPatternNode < ::Prism::Node
+  # def initialize: (Node? constant, Node left, Array[Node] requireds, Node right, Location? opening_loc, Location? closing_loc, Location location) -> void
+  #
+  # @return [FindPatternNode] a new instance of FindPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6244
+  def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6255
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6260
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6306
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6241
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6275
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6265
+  def compact_child_nodes; end
+
+  # attr_reader constant: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6226
+  sig { returns(T.nilable(Prism::Node)) }
+  def constant; end
+
+  # def copy: (**params) -> FindPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6280
+  sig { params(params: T.untyped).returns(Prism::FindPatternNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6260
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6296
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6311
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader left: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6229
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6301
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6238
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader requireds: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6232
+  sig { returns(T::Array[Prism::Node]) }
+  def requireds; end
+
+  # attr_reader right: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6235
+  sig { returns(Prism::Node) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6343
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6353
+    def type; end
+  end
+end
+
+# Represents the use of the `..` or `...` operators to create flip flops.
+#
+#     baz if foo .. bar
+#            ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6363
+class Prism::FlipFlopNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? left, Node? right, Location operator_loc, Location location) -> void
+  #
+  # @return [FlipFlopNode] a new instance of FlipFlopNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6376
+  def initialize(flags, left, right, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6385
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6390
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6403
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6395
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> FlipFlopNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6408
+  sig { params(params: T.untyped).returns(Prism::FlipFlopNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6390
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6422
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6427
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6437
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader left: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6367
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6432
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6373
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader right: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6370
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6471
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6364
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6481
+    def type; end
+  end
+end
+
+# Represents a floating point number literal.
+#
+#     1.0
+#     ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6491
+class Prism::FloatNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [FloatNode] a new instance of FloatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6492
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6497
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6502
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6512
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6507
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> FloatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6517
+  sig { params(params: T.untyped).returns(Prism::FloatNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6502
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6527
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6532
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6551
+  def type; end
+
+  # Returns the value of the node as a Ruby Float.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:62
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6561
+    def type; end
+  end
+end
+
+# Represents the use of the `for` keyword.
+#
+#     for i in a end
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6571
+class Prism::ForNode < ::Prism::Node
+  # def initialize: (Node index, Node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc, Location location) -> void
+  #
+  # @return [ForNode] a new instance of ForNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6593
+  def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6605
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6610
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # attr_reader collection: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6575
+  sig { returns(Prism::Node) }
+  def collection; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6624
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6615
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ForNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6629
+  sig { params(params: T.untyped).returns(Prism::ForNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6610
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6646
+  def deconstruct_keys(keys); end
+
+  # def do_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6661
+  sig { returns(T.nilable(String)) }
+  def do_keyword; end
+
+  # attr_reader do_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6587
+  sig { returns(T.nilable(Prism::Location)) }
+  def do_keyword_loc; end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6666
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6590
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def for_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6651
+  sig { returns(String) }
+  def for_keyword; end
+
+  # attr_reader for_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6581
+  sig { returns(Prism::Location) }
+  def for_keyword_loc; end
+
+  # def in_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6656
+  sig { returns(String) }
+  def in_keyword; end
+
+  # attr_reader in_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6584
+  sig { returns(Prism::Location) }
+  def in_keyword_loc; end
+
+  # attr_reader index: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6572
+  sig { returns(Prism::Node) }
+  def index; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6671
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6578
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6704
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6714
+    def type; end
+  end
+end
+
+# Represents forwarding all arguments to this method to another method.
+#
+#     def foo(...)
+#       bar(...)
+#           ^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:6726
+class Prism::ForwardingArgumentsNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6727
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6732
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6737
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6747
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6742
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ForwardingArgumentsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6752
+  sig { params(params: T.untyped).returns(Prism::ForwardingArgumentsNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6737
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6762
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6767
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6786
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6796
+    def type; end
+  end
+end
+
+# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+#
+#     def foo(...)
+#             ^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:6807
+class Prism::ForwardingParameterNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6808
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6813
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6818
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6828
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6823
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ForwardingParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6833
+  sig { params(params: T.untyped).returns(Prism::ForwardingParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6818
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6843
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6848
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6867
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6877
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword without parentheses or arguments.
+#
+#     super
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6887
+class Prism::ForwardingSuperNode < ::Prism::Node
+  # def initialize: (BlockNode? block, Location location) -> void
+  #
+  # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6891
+  def initialize(block, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6897
+  def accept(visitor); end
+
+  # attr_reader block: BlockNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6888
+  sig { returns(T.nilable(Prism::BlockNode)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6902
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6914
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6907
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ForwardingSuperNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6919
+  sig { params(params: T.untyped).returns(Prism::ForwardingSuperNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6902
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { block: BlockNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6930
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6935
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6960
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:6970
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a global variable.
+#
+#     $target &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:6980
+class Prism::GlobalVariableAndWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6993
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7002
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7007
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7017
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7012
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7022
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7007
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7036
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7046
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6981
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6984
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7041
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6987
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7070
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:6990
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7080
+    def type; end
+  end
+end
+
+# Represents assigning to a global variable using an operator that isn't `=`.
+#
+#     $target += value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7090
+class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+  #
+  # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7106
+  def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7116
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7121
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7131
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7126
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7136
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7121
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7151
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7156
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7091
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7094
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7103
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7097
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7181
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7100
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7191
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a global variable.
+#
+#     $target ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7201
+class Prism::GlobalVariableOrWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7214
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7223
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7228
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7238
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7233
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7243
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7228
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7257
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7267
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7202
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7205
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7262
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7208
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7291
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7211
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7301
+    def type; end
+  end
+end
+
+# Represents referencing a global variable.
+#
+#     $foo
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7315
+class Prism::GlobalVariableReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7319
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7325
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7330
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7340
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7335
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7345
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7330
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7356
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7361
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # 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`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7316
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7381
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7391
+    def type; end
+  end
+end
+
+# Represents writing to a global variable in a context that doesn't have an explicit value.
+#
+#     $foo, $bar = baz
+#     ^^^^  ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7401
+class Prism::GlobalVariableTargetNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7405
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7411
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7416
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7426
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7421
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7431
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7416
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7442
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7447
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7402
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7467
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7477
+    def type; end
+  end
+end
+
+# Represents writing to a global variable.
+#
+#     $foo = 1
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7487
+class Prism::GlobalVariableWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+  #
+  # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7500
+  def initialize(name, name_loc, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7509
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7514
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7524
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7519
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> GlobalVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7529
+  sig { params(params: T.untyped).returns(Prism::GlobalVariableWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7514
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7543
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7553
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7488
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7491
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7548
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7497
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7577
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7494
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7587
+    def type; end
+  end
+end
+
+# Represents a hash literal.
+#
+#     { a => b }
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7600
+class Prism::HashNode < ::Prism::Node
+  # def initialize: (Location opening_loc, Array[Node] elements, Location closing_loc, Location location) -> void
+  #
+  # @return [HashNode] a new instance of HashNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7619
+  def initialize(opening_loc, elements, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7627
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7632
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7670
+  sig { returns(String) }
+  def closing; end
+
+  # The location of the closing brace.
+  #
+  #     { a => b }
+  #              ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7616
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7642
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7637
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> HashNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7647
+  sig { params(params: T.untyped).returns(Prism::HashNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7632
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7660
+  def deconstruct_keys(keys); end
+
+  # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
+  #
+  #     { a: b }
+  #       ^^^^
+  #
+  #     { **foo }
+  #       ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7610
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7675
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7665
+  sig { returns(String) }
+  def opening; end
+
+  # The location of the opening brace.
+  #
+  #     { a => b }
+  #     ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7601
+  sig { returns(Prism::Location) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7697
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7707
+    def type; end
+  end
+end
+
+# Represents a hash pattern in pattern matching.
+#
+#     foo => { a: 1, b: 2 }
+#            ^^^^^^^^^^^^^^
+#
+#     foo => { a: 1, b: 2, **c }
+#            ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7720
+class Prism::HashPatternNode < ::Prism::Node
+  # def initialize: (Node? constant, Array[Node] elements, Node? rest, Location? opening_loc, Location? closing_loc, Location location) -> void
+  #
+  # @return [HashPatternNode] a new instance of HashPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7736
+  def initialize(constant, elements, rest, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7746
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7751
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7795
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7733
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7765
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7756
+  def compact_child_nodes; end
+
+  # attr_reader constant: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7721
+  sig { returns(T.nilable(Prism::Node)) }
+  def constant; end
+
+  # def copy: (**params) -> HashPatternNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7770
+  sig { params(params: T.untyped).returns(Prism::HashPatternNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7751
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7785
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7724
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7800
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7790
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7730
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7727
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7834
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7844
+    def type; end
+  end
+end
+
+# source://prism-0.20.0/lib/prism/node_ext.rb:35
+module Prism::HeredocQuery
+  # Returns true if this node was represented as a heredoc in the source code.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:37
+  def heredoc?; end
+end
+
+# Represents the use of the `if` keyword, either in the block form or the modifier form.
+#
+#     bar if foo
+#     ^^^^^^^^^^
+#
+#     if foo then bar end
+#     ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:7857
+class Prism::IfNode < ::Prism::Node
+  # def initialize: (Location? if_keyword_loc, Node predicate, Location? then_keyword_loc, StatementsNode? statements, Node? consequent, Location? end_keyword_loc, Location location) -> void
+  #
+  # @return [IfNode] a new instance of IfNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7876
+  def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7887
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7896
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7910
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7901
+  def compact_child_nodes; end
+
+  # attr_reader consequent: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7870
+  sig { returns(T.nilable(Prism::Node)) }
+  def consequent; end
+
+  # def copy: (**params) -> IfNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7915
+  sig { params(params: T.untyped).returns(Prism::IfNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7896
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7931
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7946
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7873
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # def if_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7936
+  sig { returns(T.nilable(String)) }
+  def if_keyword; end
+
+  # attr_reader if_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7858
+  sig { returns(T.nilable(Prism::Location)) }
+  def if_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7951
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader predicate: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7861
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:7891
+  def set_newline_flag(newline_marked); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7867
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7941
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
+  # attr_reader then_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7864
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:7987
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:7997
+    def type; end
+  end
+end
+
+# Represents an imaginary number literal.
+#
+#     1.0i
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8007
+class Prism::ImaginaryNode < ::Prism::Node
+  # def initialize: (Node numeric, Location location) -> void
+  #
+  # @return [ImaginaryNode] a new instance of ImaginaryNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8011
+  def initialize(numeric, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8017
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8022
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8032
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8027
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ImaginaryNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8037
+  sig { params(params: T.untyped).returns(Prism::ImaginaryNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8022
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8048
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8053
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader numeric: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8008
+  sig { returns(Prism::Node) }
+  def numeric; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8074
+  def type; end
+
+  # Returns the value of the node as a Ruby Complex.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:69
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8084
+    def type; end
+  end
+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: }
+#              ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8100
+class Prism::ImplicitNode < ::Prism::Node
+  # def initialize: (Node value, Location location) -> void
+  #
+  # @return [ImplicitNode] a new instance of ImplicitNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8104
+  def initialize(value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8110
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8115
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8125
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8120
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ImplicitNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8130
+  sig { params(params: T.untyped).returns(Prism::ImplicitNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8115
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8141
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8146
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8167
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8101
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8177
+    def type; end
+  end
+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
+#        ^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8196
+class Prism::ImplicitRestNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [ImplicitRestNode] a new instance of ImplicitRestNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8197
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8202
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8207
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8217
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8212
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ImplicitRestNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8222
+  sig { params(params: T.untyped).returns(Prism::ImplicitRestNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8207
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8232
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8237
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8256
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8266
+    def type; end
+  end
+end
+
+# Represents the use of the `in` keyword in a case statement.
+#
+#     case a; in b then c end
+#             ^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8276
+class Prism::InNode < ::Prism::Node
+  # def initialize: (Node pattern, StatementsNode? statements, Location in_loc, Location? then_loc, Location location) -> void
+  #
+  # @return [InNode] a new instance of InNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8289
+  def initialize(pattern, statements, in_loc, then_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8298
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8303
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8316
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8308
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8321
+  sig { params(params: T.untyped).returns(Prism::InNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8303
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8335
+  def deconstruct_keys(keys); end
+
+  # def in: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8340
+  sig { returns(String) }
+  def in; end
+
+  # attr_reader in_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8283
+  sig { returns(Prism::Location) }
+  def in_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8350
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader pattern: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8277
+  sig { returns(Prism::Node) }
+  def pattern; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8280
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8345
+  sig { returns(T.nilable(String)) }
+  def then; end
+
+  # attr_reader then_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8286
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8379
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8389
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call to the `[]` method.
+#
+#     foo.bar[baz] &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8399
+class Prism::IndexAndWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8427
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8441
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8412
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8500
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8418
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8510
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8406
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8446
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8520
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8415
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8461
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8451
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> IndexAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8466
+  sig { params(params: T.untyped).returns(Prism::IndexAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8446
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8485
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8505
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8530
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8515
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8409
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8525
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8421
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8403
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8490
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8575
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8424
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8495
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8400
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8585
+    def type; end
+  end
+end
+
+# Represents the use of an assignment operator on a call to `[]`.
+#
+#     foo.bar[baz] += value
+#     ^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8595
+class Prism::IndexOperatorWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Symbol operator, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8626
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8641
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8608
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8701
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8614
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8711
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8602
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8646
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8721
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8611
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8661
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8651
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> IndexOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8666
+  sig { params(params: T.untyped).returns(Prism::IndexOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8646
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator: Symbol, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8686
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8706
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8726
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8716
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8605
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8617
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8620
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8599
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8691
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8772
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8623
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8696
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8596
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8782
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call to `[]`.
+#
+#     foo.bar[baz] ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8792
+class Prism::IndexOrWriteNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8820
+  def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8834
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8805
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8893
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8811
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8903
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8799
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8839
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8913
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8808
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8854
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8844
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> IndexOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8859
+  sig { params(params: T.untyped).returns(Prism::IndexOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8839
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8878
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8898
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8923
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8908
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8802
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8918
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8814
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8796
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8883
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8968
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8817
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8888
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8793
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:8978
+    def type; end
+  end
+end
+
+# Represents assigning to an index.
+#
+#     foo[bar], = 1
+#     ^^^^^^^^
+#
+#     begin
+#     rescue => foo[bar]
+#               ^^^^^^^^
+#     end
+#
+#     for foo[bar] in baz do end
+#         ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:8996
+class Prism::IndexTargetNode < ::Prism::Node
+  # def initialize: (Integer flags, Node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Node? block, Location location) -> void
+  #
+  # @return [IndexTargetNode] a new instance of IndexTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9015
+  def initialize(flags, receiver, opening_loc, arguments, closing_loc, block, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9026
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9006
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9081
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9012
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9031
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9096
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9009
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9045
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9036
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> IndexTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9050
+  sig { params(params: T.untyped).returns(Prism::IndexTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9031
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9066
+  def deconstruct_keys(keys); end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9086
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9101
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9091
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9003
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader receiver: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9000
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9071
+  sig { returns(T::Boolean) }
+  def safe_navigation?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9138
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9076
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:8997
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9148
+    def type; end
+  end
+end
+
+# InlineComment objects are the most common. They correspond to comments in
+# the source file like this one that start with #.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:247
+class Prism::InlineComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:253
+  def inspect; end
+
+  # Returns true if this comment happens on the same line as other code and
+  # false if the comment is by itself.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:248
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# Represents the use of the `&&=` operator for assignment to an instance variable.
+#
+#     @target &&= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9158
+class Prism::InstanceVariableAndWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9171
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9180
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9185
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9195
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9190
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9200
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9185
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9214
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9224
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9159
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9162
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9219
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9165
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9248
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9168
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9258
+    def type; end
+  end
+end
+
+# Represents assigning to an instance variable using an operator that isn't `=`.
+#
+#     @target += value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9268
+class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Symbol operator, Location location) -> void
+  #
+  # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9284
+  def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9294
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9299
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9309
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9304
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9314
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9299
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9329
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9334
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9269
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9272
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9281
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9275
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9359
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9278
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9369
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to an instance variable.
+#
+#     @target ||= value
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9379
+class Prism::InstanceVariableOrWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9392
+  def initialize(name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9401
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9406
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9416
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9411
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9421
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9406
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9435
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9445
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9380
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9383
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9440
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9386
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9469
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9389
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9479
+    def type; end
+  end
+end
+
+# Represents referencing an instance variable.
+#
+#     @foo
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9493
+class Prism::InstanceVariableReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9497
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9503
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9508
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9518
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9513
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9523
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9508
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9534
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9539
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @x     # name `:@x`
+  #
+  #     @_test # name `:@_test`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9494
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9559
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9569
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable in a context that doesn't have an explicit value.
+#
+#     @foo, @bar = baz
+#     ^^^^  ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9579
+class Prism::InstanceVariableTargetNode < ::Prism::Node
+  # def initialize: (Symbol name, Location location) -> void
+  #
+  # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9583
+  def initialize(name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9589
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9594
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9604
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9599
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9609
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9594
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9620
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9625
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9580
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9645
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9655
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable.
+#
+#     @foo = 1
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9665
+class Prism::InstanceVariableWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Location name_loc, Node value, Location operator_loc, Location location) -> void
+  #
+  # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9678
+  def initialize(name, name_loc, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9687
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9692
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9702
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9697
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InstanceVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9707
+  sig { params(params: T.untyped).returns(Prism::InstanceVariableWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9692
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9721
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9731
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9666
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9669
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9726
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9675
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9755
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9672
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9765
+    def type; end
+  end
+end
+
+# Flags for integer nodes that correspond to the base of the integer.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17587
+module Prism::IntegerBaseFlags; end
+
+# 0b prefix
+#
+# source://prism-0.20.0/lib/prism/node.rb:17589
+Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
+
+# 0d or no prefix
+#
+# source://prism-0.20.0/lib/prism/node.rb:17592
+Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0x prefix
+#
+# source://prism-0.20.0/lib/prism/node.rb:17598
+Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0o or 0 prefix
+#
+# source://prism-0.20.0/lib/prism/node.rb:17595
+Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an integer number literal.
+#
+#     1
+#     ^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9775
+class Prism::IntegerNode < ::Prism::Node
+  # def initialize: (Integer flags, Location location) -> void
+  #
+  # @return [IntegerNode] a new instance of IntegerNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9779
+  def initialize(flags, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9785
+  def accept(visitor); end
+
+  # def binary?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9821
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9790
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9800
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9795
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> IntegerNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9805
+  sig { params(params: T.untyped).returns(Prism::IntegerNode) }
+  def copy(**params); end
+
+  # def decimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9826
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9790
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9816
+  def deconstruct_keys(keys); end
+
+  # def hexadecimal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9836
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9841
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def octal?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9831
+  sig { returns(T::Boolean) }
+  def octal?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9862
+  def type; end
+
+  # Returns the value of the node as a Ruby Integer.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:76
+  def value; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9776
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:9872
+    def type; end
+  end
+end
+
+# Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+#
+#     if /foo #{bar} baz/ then end
+#        ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:9882
+class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # def initialize: (Integer flags, Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+  #
+  # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9895
+  def initialize(flags, opening_loc, parts, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9904
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9973
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9914
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10008
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9892
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9924
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9919
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InterpolatedMatchLastLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9929
+  sig { params(params: T.untyped).returns(Prism::InterpolatedMatchLastLineNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9914
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9943
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9968
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9953
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9993
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9998
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9988
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9948
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10013
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9958
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9963
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10003
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9886
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9889
+  sig { returns(T::Array[Prism::Node]) }
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:9908
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10037
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9983
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9978
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:9883
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10047
+    def type; end
+  end
+end
+
+# Represents a regular expression literal that contains interpolation.
+#
+#     /foo #{bar} baz/
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10057
+class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # def initialize: (Integer flags, Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+  #
+  # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10070
+  def initialize(flags, opening_loc, parts, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10079
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10148
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10089
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10183
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10067
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10099
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10094
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InterpolatedRegularExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10104
+  sig { params(params: T.untyped).returns(Prism::InterpolatedRegularExpressionNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10089
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10118
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10143
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10128
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10168
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10173
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10163
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10123
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10188
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10133
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10138
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10178
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10061
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10064
+  sig { returns(T::Array[Prism::Node]) }
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:10083
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10212
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10158
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10153
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10058
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10222
+    def type; end
+  end
+end
+
+# Represents a string literal that contains interpolation.
+#
+#     "foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10232
+class Prism::InterpolatedStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # def initialize: (Location? opening_loc, Array[Node] parts, Location? closing_loc, Location location) -> void
+  #
+  # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10242
+  def initialize(opening_loc, parts, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10250
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10260
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10298
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10239
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10270
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10265
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InterpolatedStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10275
+  sig { params(params: T.untyped).returns(Prism::InterpolatedStringNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10260
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10288
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10303
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10293
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10233
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10236
+  sig { returns(T::Array[Prism::Node]) }
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:10254
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10325
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10335
+    def type; end
+  end
+end
+
+# Represents a symbol literal that contains interpolation.
+#
+#     :"foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10345
+class Prism::InterpolatedSymbolNode < ::Prism::Node
+  # def initialize: (Location? opening_loc, Array[Node] parts, Location? closing_loc, Location location) -> void
+  #
+  # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10355
+  def initialize(opening_loc, parts, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10363
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10373
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10411
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10352
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10383
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10378
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InterpolatedSymbolNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10388
+  sig { params(params: T.untyped).returns(Prism::InterpolatedSymbolNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10373
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10401
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10416
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10406
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10346
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10349
+  sig { returns(T::Array[Prism::Node]) }
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:10367
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10438
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10448
+    def type; end
+  end
+end
+
+# Represents an xstring literal that contains interpolation.
+#
+#     `foo #{bar} baz`
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10458
+class Prism::InterpolatedXStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # def initialize: (Location opening_loc, Array[Node] parts, Location closing_loc, Location location) -> void
+  #
+  # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10468
+  def initialize(opening_loc, parts, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10476
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10486
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10524
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10465
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10496
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10491
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> InterpolatedXStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10501
+  sig { params(params: T.untyped).returns(Prism::InterpolatedXStringNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10486
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10514
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10529
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10519
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10459
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10462
+  sig { returns(T::Array[Prism::Node]) }
+  def parts; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:10480
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10551
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10561
+    def type; end
+  end
+end
+
+# Represents a hash literal without opening and closing braces.
+#
+#     foo(a: b)
+#         ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10571
+class Prism::KeywordHashNode < ::Prism::Node
+  # def initialize: (Integer flags, Array[Node] elements, Location location) -> void
+  #
+  # @return [KeywordHashNode] a new instance of KeywordHashNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10578
+  def initialize(flags, elements, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10585
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10590
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10600
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10595
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> KeywordHashNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10605
+  sig { params(params: T.untyped).returns(Prism::KeywordHashNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10590
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Node], location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10617
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10575
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10627
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def symbol_keys?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10622
+  sig { returns(T::Boolean) }
+  def symbol_keys?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10649
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10572
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10659
+    def type; end
+  end
+end
+
+# Flags for keyword hash nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17602
+module Prism::KeywordHashNodeFlags; end
+
+# a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
+#
+# source://prism-0.20.0/lib/prism/node.rb:17604
+Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer)
+
+# Represents a keyword rest parameter to a method, block, or lambda definition.
+#
+#     def a(**b)
+#           ^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:10670
+class Prism::KeywordRestParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+  #
+  # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10683
+  def initialize(flags, name, name_loc, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10692
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10697
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10707
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10702
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> KeywordRestParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10712
+  sig { params(params: T.untyped).returns(Prism::KeywordRestParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10697
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10726
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10741
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10674
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10677
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10736
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10680
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10731
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10769
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10671
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10779
+    def type; end
+  end
+end
+
+# Represents using a lambda literal (not the lambda method call).
+#
+#     ->(value) { value * 2 }
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10789
+class Prism::LambdaNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, Node? parameters, Node? body, Location location) -> void
+  #
+  # @return [LambdaNode] a new instance of LambdaNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10808
+  def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10819
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10805
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10824
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10873
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10799
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10837
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10829
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LambdaNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10842
+  sig { params(params: T.untyped).returns(Prism::LambdaNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10824
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10858
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10878
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10790
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10868
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10796
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10863
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10793
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader parameters: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10802
+  sig { returns(T.nilable(Prism::Node)) }
+  def parameters; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10913
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:10923
+    def type; end
+  end
+end
+
+# This class is responsible for lexing the source using prism and then
+# converting those tokens to be compatible with Ripper. In the vast majority
+# of cases, this is a one-to-one mapping of the token type. Everything else
+# generally lines up. However, there are a few cases that require special
+# handling.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:11
+class Prism::LexCompat
+  # @return [LexCompat] a new instance of LexCompat
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:599
+  def initialize(source, **options); end
+
+  # Returns the value of attribute options.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:597
+  def options; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:604
+  def result; end
+
+  # Returns the value of attribute source.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:597
+  def source; end
+end
+
+# Ripper doesn't include the rest of the token in the event, so we need to
+# trim it down to just the content on the first line when comparing.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:210
+class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:211
+  def ==(other); end
+end
+
+# A heredoc in this case is a list of tokens that belong to the body of the
+# heredoc that should be appended onto the list of tokens when the heredoc
+# closes.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:271
+module Prism::LexCompat::Heredoc
+  class << self
+    # Here we will split between the two types of heredocs and return the
+    # object that will store their tokens.
+    #
+    # source://prism-0.20.0/lib/prism/lex_compat.rb:583
+    def build(opening); end
+  end
+end
+
+# Dash heredocs are a little more complicated. They are a list of tokens
+# that need to be split on "\\\n" to mimic Ripper's behavior. We also need
+# to keep track of the state that the heredoc was opened in.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:295
+class Prism::LexCompat::Heredoc::DashHeredoc
+  # @return [DashHeredoc] a new instance of DashHeredoc
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:298
+  def initialize(split); end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:303
+  def <<(token); end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:296
+  def split; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:307
+  def to_a; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:296
+  def tokens; end
+end
+
+# Heredocs that are dedenting heredocs are a little more complicated.
+# Ripper outputs on_ignored_sp tokens for the whitespace that is being
+# removed from the output. prism only modifies the node itself and keeps
+# the token the same. This simplifies prism, but makes comparing against
+# Ripper much harder because there is a length mismatch.
+#
+# Fortunately, we already have to pull out the heredoc tokens in order to
+# insert them into the stream in the correct order. As such, we can do
+# some extra manipulation on the tokens to make them match Ripper's
+# output by mirroring the dedent logic that Ripper uses.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:354
+class Prism::LexCompat::Heredoc::DedentingHeredoc
+  # @return [DedentingHeredoc] a new instance of DedentingHeredoc
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:359
+  def initialize; end
+
+  # As tokens are coming in, we track the minimum amount of common leading
+  # whitespace on plain string content tokens. This allows us to later
+  # remove that amount of whitespace from the beginning of each line.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:370
+  def <<(token); end
+
+  # Returns the value of attribute dedent.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:357
+  def dedent; end
+
+  # Returns the value of attribute dedent_next.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:357
+  def dedent_next; end
+
+  # Returns the value of attribute embexpr_balance.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:357
+  def embexpr_balance; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:407
+  def to_a; end
+
+  # Returns the value of attribute tokens.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:357
+  def tokens; end
+end
+
+# source://prism-0.20.0/lib/prism/lex_compat.rb:355
+Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# Heredocs that are no dash or tilde heredocs are just a list of tokens.
+# We need to keep them around so that we can insert them in the correct
+# order back into the token stream and set the state of the last token to
+# the state that the heredoc was opened in.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:276
+class Prism::LexCompat::Heredoc::PlainHeredoc
+  # @return [PlainHeredoc] a new instance of PlainHeredoc
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:279
+  def initialize; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:283
+  def <<(token); end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:287
+  def to_a; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:277
+  def tokens; end
+end
+
+# Ident tokens for the most part are exactly the same, except sometimes we
+# know an ident is a local when ripper doesn't (when they are introduced
+# through named captures in regular expressions). In that case we don't
+# compare the state.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:228
+class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:229
+  def ==(other); end
+end
+
+# Tokens where state should be ignored
+# used for :on_comment, :on_heredoc_end, :on_embexpr_end
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:218
+class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:219
+  def ==(other); end
+end
+
+# Ignored newlines can occasionally have a LABEL state attached to them, so
+# we compare the state differently here.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:239
+class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:240
+  def ==(other); end
+end
+
+# If we have an identifier that follows a method name like:
+#
+#     def foo bar
+#
+# then Ripper will mark bar as END|LABEL if there is a local in a parent
+# scope named bar because it hasn't pushed the local table yet. We do this
+# more accurately, so we need to allow comparing against both END and
+# END|LABEL.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:259
+class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:260
+  def ==(other); end
+end
+
+# This is a mapping of prism token types to Ripper token types. This is a
+# many-to-one mapping because we split up our token types, whereas Ripper
+# tends to group them.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:15
+Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
+
+# When we produce tokens, we produce the same arrays that Ripper does.
+# However, we add a couple of convenience methods onto them to make them a
+# little easier to work with. We delegate all other methods to the array.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:187
+class Prism::LexCompat::Token < ::SimpleDelegator
+  # The type of the token.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:193
+  def event; end
+
+  # The location of the token in the source.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:188
+  def location; end
+
+  # The state of the lexer when this token was produced.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:203
+  def state; end
+
+  # The slice of the source that this token represents.
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:198
+  def value; end
+end
+
+# This is a class that wraps the Ripper lexer to produce almost exactly the
+# same tokens.
+#
+# source://prism-0.20.0/lib/prism/lex_compat.rb:852
+class Prism::LexRipper
+  # @return [LexRipper] a new instance of LexRipper
+  #
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:855
+  def initialize(source); end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:859
+  def result; end
+
+  # source://prism-0.20.0/lib/prism/lex_compat.rb:853
+  def source; end
+end
+
+# Represents the use of the `&&=` operator for assignment to a local variable.
+#
+#     target &&= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:10933
+class Prism::LocalVariableAndWriteNode < ::Prism::Node
+  # def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Integer depth, Location location) -> void
+  #
+  # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10949
+  def initialize(name_loc, operator_loc, value, name, depth, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10959
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10964
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10974
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10969
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableAndWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10979
+  sig { params(params: T.untyped).returns(Prism::LocalVariableAndWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10964
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10994
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10946
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11004
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10943
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10934
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10999
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10937
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11029
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:10940
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11039
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable using an operator that isn't `=`.
+#
+#     target += value
+#     ^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11049
+class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
+  # def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Symbol operator, Integer depth, Location location) -> void
+  #
+  # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11068
+  def initialize(name_loc, operator_loc, value, name, operator, depth, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11079
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11084
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11094
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11089
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableOperatorWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11099
+  sig { params(params: T.untyped).returns(Prism::LocalVariableOperatorWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11084
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11115
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11065
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11120
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11059
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11050
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # attr_reader operator: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11062
+  sig { returns(Symbol) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11053
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11146
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11056
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11156
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a local variable.
+#
+#     target ||= value
+#     ^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11166
+class Prism::LocalVariableOrWriteNode < ::Prism::Node
+  # def initialize: (Location name_loc, Location operator_loc, Node value, Symbol name, Integer depth, Location location) -> void
+  #
+  # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11182
+  def initialize(name_loc, operator_loc, value, name, depth, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11192
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11197
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11207
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11202
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableOrWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11212
+  sig { params(params: T.untyped).returns(Prism::LocalVariableOrWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11197
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11227
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11179
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11237
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11176
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11167
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11232
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11170
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11262
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11173
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11272
+    def type; end
+  end
+end
+
+# Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
+#
+#     foo
+#     ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11294
+class Prism::LocalVariableReadNode < ::Prism::Node
+  # def initialize: (Symbol name, Integer depth, Location location) -> void
+  #
+  # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11307
+  def initialize(name, depth, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11314
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11319
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11329
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11324
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11334
+  sig { params(params: T.untyped).returns(Prism::LocalVariableReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11319
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11346
+  def deconstruct_keys(keys); end
+
+  # The number of visible scopes that should be searched to find the origin of this local variable.
+  #
+  #     foo = 1; foo # depth 0
+  #
+  #     bar = 2; tap { bar } # depth 1
+  #
+  # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11304
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11351
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     x      # name `:x`
+  #
+  #     _Test  # name `:_Test`
+  #
+  # Note that this can also be an underscore followed by a number for the default block parameters.
+  #
+  #     _1     # name `:_1`
+  #
+  # Finally, for the default `it` block parameter, the name is `0it`. This is to distinguish it from an `it` local variable that is explicitly declared.
+  #
+  #     it     # name `:0it`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11295
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11372
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11382
+    def type; end
+  end
+end
+
+# Represents writing to a local variable in a context that doesn't have an explicit value.
+#
+#     foo, bar = baz
+#     ^^^  ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11392
+class Prism::LocalVariableTargetNode < ::Prism::Node
+  # def initialize: (Symbol name, Integer depth, Location location) -> void
+  #
+  # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11399
+  def initialize(name, depth, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11406
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11411
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11421
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11416
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11426
+  sig { params(params: T.untyped).returns(Prism::LocalVariableTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11411
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11438
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11396
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11443
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11393
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11464
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11474
+    def type; end
+  end
+end
+
+# Represents writing to a local variable.
+#
+#     foo = 1
+#     ^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11484
+class Prism::LocalVariableWriteNode < ::Prism::Node
+  # def initialize: (Symbol name, Integer depth, Location name_loc, Node value, Location operator_loc, Location location) -> void
+  #
+  # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11500
+  def initialize(name, depth, name_loc, value, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11510
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11515
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11525
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11520
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> LocalVariableWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11530
+  sig { params(params: T.untyped).returns(Prism::LocalVariableWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11515
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11545
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11488
+  sig { returns(Integer) }
+  def depth; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11555
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11485
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11491
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11550
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11497
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11580
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11494
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11590
+    def type; end
+  end
+end
+
+# This represents a location in the source.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:91
+class Prism::Location
+  # Create a new location object with the given source, start byte offset, and
+  # byte length.
+  #
+  # @return [Location] a new instance of Location
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:108
+  def initialize(source, start_offset, length); end
+
+  # Returns true if the given other location is equal to this location.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:202
+  def ==(other); end
+
+  # The list of comments attached to this location
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:104
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  # Create a new location object with the given options.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:116
+  sig { params(options: T.untyped).returns(Prism::Location) }
+  def copy(**options); end
+
+  # Implement the hash pattern matching interface for Location.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:192
+  def deconstruct_keys(keys); end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:187
+  def end_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # ends.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:147
+  def end_character_offset; end
+
+  # The column number in bytes where this location ends from the start of the
+  # line.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:181
+  sig { returns(Integer) }
+  def end_column; end
+
+  # The line number where this location ends.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:163
+  sig { returns(Integer) }
+  def end_line; end
+
+  # The byte offset from the beginning of the source where this location ends.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:141
+  sig { returns(Integer) }
+  def end_offset; end
+
+  # Returns a string representation of this location.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:125
+  def inspect; end
+
+  # Returns a new location that stretches from this location to the given
+  # other location. Raises an error if this location is not before the other
+  # location or if they don't share the same source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:211
+  def join(other); end
+
+  # The length of this location in bytes.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:101
+  def length; end
+
+  # Implement the pretty print interface for Location.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:197
+  def pretty_print(q); end
+
+  # The source code that this location represents.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:130
+  sig { returns(String) }
+  def slice; end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:175
+  def start_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # starts.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:136
+  def start_character_offset; end
+
+  # The column number in bytes where this location starts from the start of
+  # the line.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:169
+  sig { returns(Integer) }
+  def start_column; end
+
+  # The line number where this location starts.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:152
+  sig { returns(Integer) }
+  def start_line; end
+
+  # The content of the line where this location starts before this location.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:157
+  def start_line_slice; end
+
+  # The byte offset from the beginning of the source where this location
+  # starts.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:98
+  sig { returns(Integer) }
+  def start_offset; end
+
+  protected
+
+  # Returns the value of attribute source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:94
+  def source; end
+
+  class << self
+    # Returns a null location that does not correspond to a source and points to
+    # the beginning of the file. Useful for when you want a location object but
+    # do not care where it points.
+    #
+    # source://prism-0.20.0/lib/prism/parse_result.rb:221
+    def null; end
+  end
+end
+
+# Flags for while and until loop nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17608
+module Prism::LoopFlags; end
+
+# a loop after a begin statement, so the body is executed first before the condition
+#
+# source://prism-0.20.0/lib/prism/node.rb:17610
+Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer)
+
+# This represents a magic comment that was encountered during parsing.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:273
+class Prism::MagicComment
+  # Create a new magic comment object with the given key and value locations.
+  #
+  # @return [MagicComment] a new instance of MagicComment
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:281
+  def initialize(key_loc, value_loc); end
+
+  # Implement the hash pattern matching interface for MagicComment.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:297
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this magic comment.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:302
+  def inspect; end
+
+  # Returns the key of the magic comment by slicing it from the source code.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:287
+  def key; end
+
+  # A Location object representing the location of the key in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:275
+  def key_loc; end
+
+  # Returns the value of the magic comment by slicing it from the source code.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:292
+  def value; end
+
+  # A Location object representing the location of the value in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:278
+  def value_loc; end
+end
+
+# Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+#
+#     if /foo/i then end
+#        ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11600
+class Prism::MatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+  #
+  # @return [MatchLastLineNode] a new instance of MatchLastLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11616
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11626
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11691
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11631
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11731
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11610
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11641
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11636
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11726
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11607
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (**params) -> MatchLastLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11646
+  sig { params(params: T.untyped).returns(Prism::MatchLastLineNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11631
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11661
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11686
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11671
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11711
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11716
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11706
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11666
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11736
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11676
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11681
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11721
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11604
+  sig { returns(Prism::Location) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11761
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11613
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11701
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11696
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11601
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11771
+    def type; end
+  end
+end
+
+# Represents the use of the modifier `in` operator.
+#
+#     foo in bar
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11781
+class Prism::MatchPredicateNode < ::Prism::Node
+  # def initialize: (Node value, Node pattern, Location operator_loc, Location location) -> void
+  #
+  # @return [MatchPredicateNode] a new instance of MatchPredicateNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11791
+  def initialize(value, pattern, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11799
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11804
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11814
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11809
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MatchPredicateNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11819
+  sig { params(params: T.untyped).returns(Prism::MatchPredicateNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11804
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, pattern: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11832
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11842
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11837
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11788
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader pattern: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11785
+  sig { returns(Prism::Node) }
+  def pattern; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11866
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11782
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11876
+    def type; end
+  end
+end
+
+# Represents the use of the `=>` operator.
+#
+#     foo => bar
+#     ^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11886
+class Prism::MatchRequiredNode < ::Prism::Node
+  # def initialize: (Node value, Node pattern, Location operator_loc, Location location) -> void
+  #
+  # @return [MatchRequiredNode] a new instance of MatchRequiredNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11896
+  def initialize(value, pattern, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11904
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11909
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11919
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11914
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MatchRequiredNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11924
+  sig { params(params: T.untyped).returns(Prism::MatchRequiredNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11909
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Node, pattern: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11937
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11947
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11942
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11893
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader pattern: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11890
+  sig { returns(Prism::Node) }
+  def pattern; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11971
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11887
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:11981
+    def type; end
+  end
+end
+
+# Represents writing local variables using a regular expression match with named capture groups.
+#
+#     /(?<foo>bar)/ =~ baz
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:11991
+class Prism::MatchWriteNode < ::Prism::Node
+  # def initialize: (CallNode call, Array[Node] targets, Location location) -> void
+  #
+  # @return [MatchWriteNode] a new instance of MatchWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11998
+  def initialize(call, targets, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12005
+  def accept(visitor); end
+
+  # attr_reader call: CallNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11992
+  sig { returns(Prism::CallNode) }
+  def call; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12010
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12020
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12015
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MatchWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12025
+  sig { params(params: T.untyped).returns(Prism::MatchWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12010
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { call: CallNode, targets: Array[Node], location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12037
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12042
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader targets: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:11995
+  sig { returns(T::Array[Prism::Node]) }
+  def targets; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12064
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12074
+    def type; end
+  end
+end
+
+# Represents a node that is missing from the source and results in a syntax error.
+#
+# source://prism-0.20.0/lib/prism/node.rb:12081
+class Prism::MissingNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [MissingNode] a new instance of MissingNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12082
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12087
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12092
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12102
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12097
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MissingNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12107
+  sig { params(params: T.untyped).returns(Prism::MissingNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12092
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12117
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12122
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12141
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12151
+    def type; end
+  end
+end
+
+# Represents a module declaration involving the `module` keyword.
+#
+#     module Foo end
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12161
+class Prism::ModuleNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, Location module_keyword_loc, Node constant_path, Node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+  #
+  # @return [ModuleNode] a new instance of ModuleNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12180
+  def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12191
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12171
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12196
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12209
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12201
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12168
+  sig { returns(Prism::Node) }
+  def constant_path; end
+
+  # def copy: (**params) -> ModuleNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12214
+  sig { params(params: T.untyped).returns(Prism::ModuleNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12196
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12230
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12240
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12174
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12245
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12162
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def module_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12235
+  sig { returns(String) }
+  def module_keyword; end
+
+  # attr_reader module_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12165
+  sig { returns(Prism::Location) }
+  def module_keyword_loc; end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12177
+  sig { returns(Symbol) }
+  def name; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12276
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12286
+    def type; end
+  end
+end
+
+# Represents a multi-target expression.
+#
+#     a, (b, c) = 1, 2, 3
+#        ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12296
+class Prism::MultiTargetNode < ::Prism::Node
+  # def initialize: (Array[Node] lefts, Node? rest, Array[Node] rights, Location? lparen_loc, Location? rparen_loc, Location location) -> void
+  #
+  # @return [MultiTargetNode] a new instance of MultiTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12312
+  def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12322
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12327
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12341
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12332
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MultiTargetNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12346
+  sig { params(params: T.untyped).returns(Prism::MultiTargetNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12327
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12361
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12376
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader lefts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12297
+  sig { returns(T::Array[Prism::Node]) }
+  def lefts; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12366
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12306
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # attr_reader rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12300
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; end
+
+  # attr_reader rights: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12303
+  sig { returns(T::Array[Prism::Node]) }
+  def rights; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12371
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12309
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12405
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12415
+    def type; end
+  end
+end
+
+# Represents a write to a multi-target expression.
+#
+#     a, b, c = 1, 2, 3
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12425
+class Prism::MultiWriteNode < ::Prism::Node
+  # def initialize: (Array[Node] lefts, Node? rest, Array[Node] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [MultiWriteNode] a new instance of MultiWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12447
+  def initialize(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12459
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12464
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12479
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12469
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> MultiWriteNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12484
+  sig { params(params: T.untyped).returns(Prism::MultiWriteNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12464
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12501
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12521
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader lefts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12426
+  sig { returns(T::Array[Prism::Node]) }
+  def lefts; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12506
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12435
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12516
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12441
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12429
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; end
+
+  # attr_reader rights: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12432
+  sig { returns(T::Array[Prism::Node]) }
+  def rights; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12511
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12438
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12553
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12444
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12563
+    def type; end
+  end
+end
+
+# This visitor walks through the tree and copies each node as it is being
+# visited. This is useful for consumers that want to mutate the tree, as you
+# can change subtrees in place without effecting the rest of the tree.
+#
+# source://prism-0.20.0/lib/prism/mutation_compiler.rb:13
+class Prism::MutationCompiler < ::Prism::Compiler
+  # Copy a AliasGlobalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:14
+  def visit_alias_global_variable_node(node); end
+
+  # Copy a AliasMethodNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:19
+  def visit_alias_method_node(node); end
+
+  # Copy a AlternationPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:24
+  def visit_alternation_pattern_node(node); end
+
+  # Copy a AndNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:29
+  def visit_and_node(node); end
+
+  # Copy a ArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:34
+  def visit_arguments_node(node); end
+
+  # Copy a ArrayNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:39
+  def visit_array_node(node); end
+
+  # Copy a ArrayPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:44
+  def visit_array_pattern_node(node); end
+
+  # Copy a AssocNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:49
+  def visit_assoc_node(node); end
+
+  # Copy a AssocSplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:54
+  def visit_assoc_splat_node(node); end
+
+  # Copy a BackReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:59
+  def visit_back_reference_read_node(node); end
+
+  # Copy a BeginNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:64
+  def visit_begin_node(node); end
+
+  # Copy a BlockArgumentNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:69
+  def visit_block_argument_node(node); end
+
+  # Copy a BlockLocalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:74
+  def visit_block_local_variable_node(node); end
+
+  # Copy a BlockNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:79
+  def visit_block_node(node); end
+
+  # Copy a BlockParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:84
+  def visit_block_parameter_node(node); end
+
+  # Copy a BlockParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:89
+  def visit_block_parameters_node(node); end
+
+  # Copy a BreakNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:94
+  def visit_break_node(node); end
+
+  # Copy a CallAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:99
+  def visit_call_and_write_node(node); end
+
+  # Copy a CallNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:104
+  def visit_call_node(node); end
+
+  # Copy a CallOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:109
+  def visit_call_operator_write_node(node); end
+
+  # Copy a CallOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:114
+  def visit_call_or_write_node(node); end
+
+  # Copy a CallTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:119
+  def visit_call_target_node(node); end
+
+  # Copy a CapturePatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:124
+  def visit_capture_pattern_node(node); end
+
+  # Copy a CaseMatchNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:129
+  def visit_case_match_node(node); end
+
+  # Copy a CaseNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:134
+  def visit_case_node(node); end
+
+  # Copy a ClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:139
+  def visit_class_node(node); end
+
+  # Copy a ClassVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:144
+  def visit_class_variable_and_write_node(node); end
+
+  # Copy a ClassVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:149
+  def visit_class_variable_operator_write_node(node); end
+
+  # Copy a ClassVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:154
+  def visit_class_variable_or_write_node(node); end
+
+  # Copy a ClassVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:159
+  def visit_class_variable_read_node(node); end
+
+  # Copy a ClassVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:164
+  def visit_class_variable_target_node(node); end
+
+  # Copy a ClassVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:169
+  def visit_class_variable_write_node(node); end
+
+  # Copy a ConstantAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:174
+  def visit_constant_and_write_node(node); end
+
+  # Copy a ConstantOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:179
+  def visit_constant_operator_write_node(node); end
+
+  # Copy a ConstantOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:184
+  def visit_constant_or_write_node(node); end
+
+  # Copy a ConstantPathAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:189
+  def visit_constant_path_and_write_node(node); end
+
+  # Copy a ConstantPathNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:194
+  def visit_constant_path_node(node); end
+
+  # Copy a ConstantPathOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:199
+  def visit_constant_path_operator_write_node(node); end
+
+  # Copy a ConstantPathOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:204
+  def visit_constant_path_or_write_node(node); end
+
+  # Copy a ConstantPathTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:209
+  def visit_constant_path_target_node(node); end
+
+  # Copy a ConstantPathWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:214
+  def visit_constant_path_write_node(node); end
+
+  # Copy a ConstantReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:219
+  def visit_constant_read_node(node); end
+
+  # Copy a ConstantTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:224
+  def visit_constant_target_node(node); end
+
+  # Copy a ConstantWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:229
+  def visit_constant_write_node(node); end
+
+  # Copy a DefNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:234
+  def visit_def_node(node); end
+
+  # Copy a DefinedNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:239
+  def visit_defined_node(node); end
+
+  # Copy a ElseNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:244
+  def visit_else_node(node); end
+
+  # Copy a EmbeddedStatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:249
+  def visit_embedded_statements_node(node); end
+
+  # Copy a EmbeddedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:254
+  def visit_embedded_variable_node(node); end
+
+  # Copy a EnsureNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:259
+  def visit_ensure_node(node); end
+
+  # Copy a FalseNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:264
+  def visit_false_node(node); end
+
+  # Copy a FindPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:269
+  def visit_find_pattern_node(node); end
+
+  # Copy a FlipFlopNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:274
+  def visit_flip_flop_node(node); end
+
+  # Copy a FloatNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:279
+  def visit_float_node(node); end
+
+  # Copy a ForNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:284
+  def visit_for_node(node); end
+
+  # Copy a ForwardingArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:289
+  def visit_forwarding_arguments_node(node); end
+
+  # Copy a ForwardingParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:294
+  def visit_forwarding_parameter_node(node); end
+
+  # Copy a ForwardingSuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:299
+  def visit_forwarding_super_node(node); end
+
+  # Copy a GlobalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:304
+  def visit_global_variable_and_write_node(node); end
+
+  # Copy a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:309
+  def visit_global_variable_operator_write_node(node); end
+
+  # Copy a GlobalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:314
+  def visit_global_variable_or_write_node(node); end
+
+  # Copy a GlobalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:319
+  def visit_global_variable_read_node(node); end
+
+  # Copy a GlobalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:324
+  def visit_global_variable_target_node(node); end
+
+  # Copy a GlobalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:329
+  def visit_global_variable_write_node(node); end
+
+  # Copy a HashNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:334
+  def visit_hash_node(node); end
+
+  # Copy a HashPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:339
+  def visit_hash_pattern_node(node); end
+
+  # Copy a IfNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:344
+  def visit_if_node(node); end
+
+  # Copy a ImaginaryNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:349
+  def visit_imaginary_node(node); end
+
+  # Copy a ImplicitNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:354
+  def visit_implicit_node(node); end
+
+  # Copy a ImplicitRestNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:359
+  def visit_implicit_rest_node(node); end
+
+  # Copy a InNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:364
+  def visit_in_node(node); end
+
+  # Copy a IndexAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:369
+  def visit_index_and_write_node(node); end
+
+  # Copy a IndexOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:374
+  def visit_index_operator_write_node(node); end
+
+  # Copy a IndexOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:379
+  def visit_index_or_write_node(node); end
+
+  # Copy a IndexTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:384
+  def visit_index_target_node(node); end
+
+  # Copy a InstanceVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:389
+  def visit_instance_variable_and_write_node(node); end
+
+  # Copy a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:394
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Copy a InstanceVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:399
+  def visit_instance_variable_or_write_node(node); end
+
+  # Copy a InstanceVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:404
+  def visit_instance_variable_read_node(node); end
+
+  # Copy a InstanceVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:409
+  def visit_instance_variable_target_node(node); end
+
+  # Copy a InstanceVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:414
+  def visit_instance_variable_write_node(node); end
+
+  # Copy a IntegerNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:419
+  def visit_integer_node(node); end
+
+  # Copy a InterpolatedMatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:424
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Copy a InterpolatedRegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:429
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Copy a InterpolatedStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:434
+  def visit_interpolated_string_node(node); end
+
+  # Copy a InterpolatedSymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:439
+  def visit_interpolated_symbol_node(node); end
+
+  # Copy a InterpolatedXStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:444
+  def visit_interpolated_x_string_node(node); end
+
+  # Copy a KeywordHashNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:449
+  def visit_keyword_hash_node(node); end
+
+  # Copy a KeywordRestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:454
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Copy a LambdaNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:459
+  def visit_lambda_node(node); end
+
+  # Copy a LocalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:464
+  def visit_local_variable_and_write_node(node); end
+
+  # Copy a LocalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:469
+  def visit_local_variable_operator_write_node(node); end
+
+  # Copy a LocalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:474
+  def visit_local_variable_or_write_node(node); end
+
+  # Copy a LocalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:479
+  def visit_local_variable_read_node(node); end
+
+  # Copy a LocalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:484
+  def visit_local_variable_target_node(node); end
+
+  # Copy a LocalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:489
+  def visit_local_variable_write_node(node); end
+
+  # Copy a MatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:494
+  def visit_match_last_line_node(node); end
+
+  # Copy a MatchPredicateNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:499
+  def visit_match_predicate_node(node); end
+
+  # Copy a MatchRequiredNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:504
+  def visit_match_required_node(node); end
+
+  # Copy a MatchWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:509
+  def visit_match_write_node(node); end
+
+  # Copy a MissingNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:514
+  def visit_missing_node(node); end
+
+  # Copy a ModuleNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:519
+  def visit_module_node(node); end
+
+  # Copy a MultiTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:524
+  def visit_multi_target_node(node); end
+
+  # Copy a MultiWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:529
+  def visit_multi_write_node(node); end
+
+  # Copy a NextNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:534
+  def visit_next_node(node); end
+
+  # Copy a NilNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:539
+  def visit_nil_node(node); end
+
+  # Copy a NoKeywordsParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:544
+  def visit_no_keywords_parameter_node(node); end
+
+  # Copy a NumberedParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:549
+  def visit_numbered_parameters_node(node); end
+
+  # Copy a NumberedReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:554
+  def visit_numbered_reference_read_node(node); end
+
+  # Copy a OptionalKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:559
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Copy a OptionalParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:564
+  def visit_optional_parameter_node(node); end
+
+  # Copy a OrNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:569
+  def visit_or_node(node); end
+
+  # Copy a ParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:574
+  def visit_parameters_node(node); end
+
+  # Copy a ParenthesesNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:579
+  def visit_parentheses_node(node); end
+
+  # Copy a PinnedExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:584
+  def visit_pinned_expression_node(node); end
+
+  # Copy a PinnedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:589
+  def visit_pinned_variable_node(node); end
+
+  # Copy a PostExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:594
+  def visit_post_execution_node(node); end
+
+  # Copy a PreExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:599
+  def visit_pre_execution_node(node); end
+
+  # Copy a ProgramNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:604
+  def visit_program_node(node); end
+
+  # Copy a RangeNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:609
+  def visit_range_node(node); end
+
+  # Copy a RationalNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:614
+  def visit_rational_node(node); end
+
+  # Copy a RedoNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:619
+  def visit_redo_node(node); end
+
+  # Copy a RegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:624
+  def visit_regular_expression_node(node); end
+
+  # Copy a RequiredKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:629
+  def visit_required_keyword_parameter_node(node); end
+
+  # Copy a RequiredParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:634
+  def visit_required_parameter_node(node); end
+
+  # Copy a RescueModifierNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:639
+  def visit_rescue_modifier_node(node); end
+
+  # Copy a RescueNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:644
+  def visit_rescue_node(node); end
+
+  # Copy a RestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:649
+  def visit_rest_parameter_node(node); end
+
+  # Copy a RetryNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:654
+  def visit_retry_node(node); end
+
+  # Copy a ReturnNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:659
+  def visit_return_node(node); end
+
+  # Copy a SelfNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:664
+  def visit_self_node(node); end
+
+  # Copy a SingletonClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:669
+  def visit_singleton_class_node(node); end
+
+  # Copy a SourceEncodingNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:674
+  def visit_source_encoding_node(node); end
+
+  # Copy a SourceFileNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:679
+  def visit_source_file_node(node); end
+
+  # Copy a SourceLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:684
+  def visit_source_line_node(node); end
+
+  # Copy a SplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:689
+  def visit_splat_node(node); end
+
+  # Copy a StatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:694
+  def visit_statements_node(node); end
+
+  # Copy a StringNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:699
+  def visit_string_node(node); end
+
+  # Copy a SuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:704
+  def visit_super_node(node); end
+
+  # Copy a SymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:709
+  def visit_symbol_node(node); end
+
+  # Copy a TrueNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:714
+  def visit_true_node(node); end
+
+  # Copy a UndefNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:719
+  def visit_undef_node(node); end
+
+  # Copy a UnlessNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:724
+  def visit_unless_node(node); end
+
+  # Copy a UntilNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:729
+  def visit_until_node(node); end
+
+  # Copy a WhenNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:734
+  def visit_when_node(node); end
+
+  # Copy a WhileNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:739
+  def visit_while_node(node); end
+
+  # Copy a XStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:744
+  def visit_x_string_node(node); end
+
+  # Copy a YieldNode node
+  #
+  # source://prism-0.20.0/lib/prism/mutation_compiler.rb:749
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `next` keyword.
+#
+#     next 1
+#     ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12573
+class Prism::NextNode < ::Prism::Node
+  # def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+  #
+  # @return [NextNode] a new instance of NextNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12580
+  def initialize(arguments, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12587
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12574
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12592
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12604
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12597
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> NextNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12609
+  sig { params(params: T.untyped).returns(Prism::NextNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12592
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12621
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12631
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12626
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12577
+  sig { returns(Prism::Location) }
+  def keyword_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12657
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12667
+    def type; end
+  end
+end
+
+# Represents the use of the `nil` keyword.
+#
+#     nil
+#     ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12677
+class Prism::NilNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [NilNode] a new instance of NilNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12678
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12683
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12688
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12698
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12693
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> NilNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12703
+  sig { params(params: T.untyped).returns(Prism::NilNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12688
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12713
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12718
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12737
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12747
+    def type; end
+  end
+end
+
+# Represents the use of `**nil` inside method arguments.
+#
+#     def a(**nil)
+#           ^^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:12758
+class Prism::NoKeywordsParameterNode < ::Prism::Node
+  # def initialize: (Location operator_loc, Location keyword_loc, Location location) -> void
+  #
+  # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12765
+  def initialize(operator_loc, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12772
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12777
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12787
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12782
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> NoKeywordsParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12792
+  sig { params(params: T.untyped).returns(Prism::NoKeywordsParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12777
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12804
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12819
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12814
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12762
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12809
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12759
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12840
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12850
+    def type; end
+  end
+end
+
+# This represents a node in the tree. It is the parent class of all of the
+# various node types.
+#
+# source://prism-0.20.0/lib/prism/node.rb:11
+class Prism::Node
+  # Accepts a visitor and calls back into the specialized visit function.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:55
+  def accept(visitor); end
+
+  # Returns an array of child nodes, including `nil`s in the place of optional
+  # nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:61
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # Returns an array of child nodes and locations that could potentially have
+  # comments attached to them.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:75
+  def comment_targets; end
+
+  # Returns an array of child nodes, excluding any `nil`s in the place of
+  # optional nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:69
+  sig { returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # Returns an array of child nodes, including `nil`s in the place of optional
+  # nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:61
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # A Location instance that represents the location of this node in the
+  # source.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16
+  def newline?; end
+
+  # Similar to inspect, but respects the current level of indentation given by
+  # the pretty print object.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:35
+  def pretty_print(q); end
+
+  # source://prism-0.20.0/lib/prism/node.rb:20
+  def set_newline_flag(newline_marked); end
+
+  # Slice the location of the node from the source.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:29
+  sig { returns(String) }
+  def slice; end
+
+  # Convert this node into a graphviz dot graph string.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:43
+  sig { returns(String) }
+  def to_dot; end
+
+  # Returns a symbol symbolizing the type of node that this represents. This
+  # is particularly useful for case statements and array comparisons.
+  #
+  # @raise [NoMethodError]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:81
+  sig { returns(Symbol) }
+  def type; end
+end
+
+# This object is responsible for generating the output for the inspect method
+# implementations of child nodes.
+#
+# source://prism-0.20.0/lib/prism/node_inspector.rb:6
+class Prism::NodeInspector
+  # @return [NodeInspector] a new instance of NodeInspector
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:9
+  def initialize(prefix = T.unsafe(nil)); end
+
+  # Appends a line to the output with the current prefix.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:15
+  def <<(line); end
+
+  # Returns a new inspector that can be used to inspect a child node.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:59
+  def child_inspector(append); end
+
+  # Generates a string that represents a child node.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:54
+  def child_node(node, append); end
+
+  # This generates a string that is used as the header of the inspect output
+  # for any given node.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:21
+  def header(node); end
+
+  # Generates a string that represents a list of nodes. It handles properly
+  # using the box drawing characters to make the output look nice.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:31
+  def list(prefix, nodes); end
+
+  # Generates a string that represents a location field on a node.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:45
+  def location(value); end
+
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:7
+  sig { returns(String) }
+  def output; end
+
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:7
+  sig { returns(String) }
+  def prefix; end
+
+  # Returns the output as a string.
+  #
+  # source://prism-0.20.0/lib/prism/node_inspector.rb:64
+  sig { returns(String) }
+  def to_str; end
+end
+
+# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
+#
+#     -> { _1 + _2 }
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12860
+class Prism::NumberedParametersNode < ::Prism::Node
+  # def initialize: (Integer maximum, Location location) -> void
+  #
+  # @return [NumberedParametersNode] a new instance of NumberedParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12864
+  def initialize(maximum, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12870
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12875
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12885
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12880
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> NumberedParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12890
+  sig { params(params: T.untyped).returns(Prism::NumberedParametersNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12875
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { maximum: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12901
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12906
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader maximum: Integer
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12861
+  sig { returns(Integer) }
+  def maximum; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12926
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:12936
+    def type; end
+  end
+end
+
+# Represents reading a numbered reference to a capture in the previous match.
+#
+#     $1
+#     ^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:12952
+class Prism::NumberedReferenceReadNode < ::Prism::Node
+  # def initialize: (Integer number, Location location) -> void
+  #
+  # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12956
+  def initialize(number, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12962
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12967
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12977
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12972
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> NumberedReferenceReadNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12982
+  sig { params(params: T.untyped).returns(Prism::NumberedReferenceReadNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12967
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { number: Integer, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12993
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12998
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # The (1-indexed, from the left) number of the capture group. Numbered references that would overflow a `uint32`  result in a `number` of exactly `2**32 - 1`.
+  #
+  #     $1          # number `1`
+  #
+  #     $5432       # number `5432`
+  #
+  #     $4294967296 # number `4294967295`
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:12953
+  sig { returns(Integer) }
+  def number; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13018
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13028
+    def type; end
+  end
+end
+
+# Represents an optional keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: 1)
+#           ^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:13039
+class Prism::OptionalKeywordParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol name, Location name_loc, Node value, Location location) -> void
+  #
+  # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13052
+  def initialize(flags, name, name_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13061
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13066
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13076
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13071
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> OptionalKeywordParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13081
+  sig { params(params: T.untyped).returns(Prism::OptionalKeywordParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13066
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13095
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13105
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13043
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13046
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13100
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13130
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13049
+  sig { returns(Prism::Node) }
+  def value; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13040
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13140
+    def type; end
+  end
+end
+
+# Represents an optional parameter to a method, block, or lambda definition.
+#
+#     def a(b = 1)
+#           ^^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:13151
+class Prism::OptionalParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol name, Location name_loc, Location operator_loc, Node value, Location location) -> void
+  #
+  # @return [OptionalParameterNode] a new instance of OptionalParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13167
+  def initialize(flags, name, name_loc, operator_loc, value, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13177
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13182
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13192
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13187
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> OptionalParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13197
+  sig { params(params: T.untyped).returns(Prism::OptionalParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13182
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13212
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13227
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13155
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13158
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13222
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13161
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13217
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13253
+  def type; end
+
+  # attr_reader value: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13164
+  sig { returns(Prism::Node) }
+  def value; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13152
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13263
+    def type; end
+  end
+end
+
+# Represents the use of the `||` operator or the `or` keyword.
+#
+#     left or right
+#     ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:13279
+class Prism::OrNode < ::Prism::Node
+  # def initialize: (Node left, Node right, Location operator_loc, Location location) -> void
+  #
+  # @return [OrNode] a new instance of OrNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13298
+  def initialize(left, right, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13306
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13311
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13321
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13316
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> OrNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13326
+  sig { params(params: T.untyped).returns(Prism::OrNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13311
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Node, right: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13339
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13349
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # 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 or right
+  #     ^^^^
+  #
+  #     1 || 2
+  #     ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13280
+  sig { returns(Prism::Node) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13344
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `or` keyword or the `||` operator.
+  #
+  #     left or right
+  #          ^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13295
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # Represents the right 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 || right
+  #             ^^^^^
+  #
+  #     1 or 2
+  #          ^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13289
+  sig { returns(Prism::Node) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13373
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13383
+    def type; end
+  end
+end
+
+# A parser for the pack template language.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:5
+module Prism::Pack
+  class << self
+    def parse(_arg0, _arg1, _arg2); end
+  end
+end
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
+
+# A directive in the pack template language.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:59
+class Prism::Pack::Directive
+  # Initialize a new directive with the given values.
+  #
+  # @return [Directive] a new instance of Directive
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:88
+  def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
+
+  # Provide a human-readable description of the directive.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:130
+  def describe; end
+
+  # The type of endianness of the directive.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:76
+  def endian; end
+
+  # The length of this directive (used for integers).
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:85
+  def length; end
+
+  # The length type of this directive (used for integers).
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:82
+  def length_type; end
+
+  # The type of signedness of the directive.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:73
+  def signed; end
+
+  # The size of the directive.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:79
+  def size; end
+
+  # A byteslice of the source string that this directive represents.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:67
+  def source; end
+
+  # The type of the directive.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:70
+  def type; end
+
+  # A symbol representing whether or not we are packing or unpacking.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:64
+  def variant; end
+
+  # A symbol representing the version of Ruby.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:61
+  def version; end
+end
+
+# The descriptions of the various types of endianness.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:101
+Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of signedness.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:110
+Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of sizes.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:117
+Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
+
+# The result of parsing a pack template.
+#
+# source://prism-0.20.0/lib/prism/pack.rb:195
+class Prism::Pack::Format
+  # Create a new Format with the given directives and encoding.
+  #
+  # @return [Format] a new instance of Format
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:203
+  def initialize(directives, encoding); end
+
+  # Provide a human-readable description of the format.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:209
+  def describe; end
+
+  # A list of the directives in the template.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:197
+  def directives; end
+
+  # The encoding of the template.
+  #
+  # source://prism-0.20.0/lib/prism/pack.rb:200
+  def encoding; end
+end
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism-0.20.0/lib/prism/pack.rb:55
+Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
+
+# Flags for parameter nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17614
+module Prism::ParameterFlags; end
+
+# a parameter name that has been repeated in the method signature
+#
+# source://prism-0.20.0/lib/prism/node.rb:17616
+Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer)
+
+# Represents the list of parameters on a method, block, or lambda definition.
+#
+#     def a(b, c, d)
+#           ^^^^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:13394
+class Prism::ParametersNode < ::Prism::Node
+  # def initialize: (Array[Node] requireds, Array[Node] optionals, Node? rest, Array[Node] posts, Array[Node] keywords, Node? keyword_rest, BlockParameterNode? block, Location location) -> void
+  #
+  # @return [ParametersNode] a new instance of ParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13416
+  def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13428
+  def accept(visitor); end
+
+  # attr_reader block: BlockParameterNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13413
+  sig { returns(T.nilable(Prism::BlockParameterNode)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13433
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13451
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13438
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ParametersNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13456
+  sig { params(params: T.untyped).returns(Prism::ParametersNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13433
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[Node], optionals: Array[Node], rest: Node?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13473
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13478
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader keyword_rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13410
+  sig { returns(T.nilable(Prism::Node)) }
+  def keyword_rest; end
+
+  # attr_reader keywords: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13407
+  sig { returns(T::Array[Prism::Node]) }
+  def keywords; end
+
+  # attr_reader optionals: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13398
+  sig { returns(T::Array[Prism::Node]) }
+  def optionals; end
+
+  # attr_reader posts: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13404
+  sig { returns(T::Array[Prism::Node]) }
+  def posts; end
+
+  # attr_reader requireds: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13395
+  sig { returns(T::Array[Prism::Node]) }
+  def requireds; end
+
+  # attr_reader rest: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13401
+  sig { returns(T.nilable(Prism::Node)) }
+  def rest; end
+
+  # Mirrors the Method#parameters method.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:149
+  def signature; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13519
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13529
+    def type; end
+  end
+end
+
+# Represents a parenthesized expression
+#
+#     (10 + 34)
+#     ^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:13539
+class Prism::ParenthesesNode < ::Prism::Node
+  # def initialize: (Node? body, Location opening_loc, Location closing_loc, Location location) -> void
+  #
+  # @return [ParenthesesNode] a new instance of ParenthesesNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13549
+  def initialize(body, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13557
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13540
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13566
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13606
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13546
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13578
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13571
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ParenthesesNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13583
+  sig { params(params: T.untyped).returns(Prism::ParenthesesNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13566
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { body: Node?, opening_loc: Location, closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13596
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13611
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13601
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13543
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:13561
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13638
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13648
+    def type; end
+  end
+end
+
+# This represents an error that was encountered during parsing.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:308
+class Prism::ParseError
+  # Create a new error object with the given message and location.
+  #
+  # @return [ParseError] a new instance of ParseError
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:319
+  def initialize(message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseError.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:326
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this error.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:331
+  def inspect; end
+
+  # The level of this error.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:316
+  def level; end
+
+  # A Location object representing the location of this error in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:313
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this error.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:310
+  sig { returns(String) }
+  def message; end
+end
+
+# This represents the result of a call to ::parse or ::parse_file. It contains
+# the AST, any comments that were encounters, and any errors that were
+# encountered.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:368
+class Prism::ParseResult
+  # Create a new parse result object with the given values.
+  #
+  # @return [ParseResult] a new instance of ParseResult
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:395
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Attach the list of comments to their respective locations in the tree.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:173
+  def attach_comments!; end
+
+  # The list of comments that were encountered during parsing.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:375
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  # An optional location that represents the location of the __END__ marker
+  # and the rest of the content of the file. This content is loaded into the
+  # DATA constant when the file being parsed is the main file being executed.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:383
+  def data_loc; end
+
+  # Implement the hash pattern matching interface for ParseResult.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:406
+  def deconstruct_keys(keys); end
+
+  # The list of errors that were generated during parsing.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:386
+  sig { returns(T::Array[Prism::ParseError]) }
+  def errors; end
+
+  # Returns true if there were errors during parsing and false if there were
+  # not.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:418
+  def failure?; end
+
+  # The list of magic comments that were encountered during parsing.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:378
+  def magic_comments; end
+
+  # Walk the tree and mark nodes that are on a new line.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:60
+  def mark_newlines!; end
+
+  # A Source instance that represents the source code that was parsed.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:392
+  sig { returns(Prism::Source) }
+  def source; end
+
+  # Returns true if there were no errors during parsing and false if there
+  # were.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:412
+  def success?; end
+
+  # The value that was generated by parsing. Normally this holds the AST, but
+  # it can sometimes how a list of tokens or other results passed back from
+  # the parser.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:372
+  sig { returns(Prism::ProgramNode) }
+  def value; end
+
+  # The list of warnings that were generated during parsing.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:389
+  sig { returns(T::Array[Prism::ParseWarning]) }
+  def warnings; end
+end
+
+# When we've parsed the source, we have both the syntax tree and the list of
+# comments that we found in the source. This class is responsible for
+# walking the tree and finding the nearest location to attach each comment.
+#
+# It does this by first finding the nearest locations to each comment.
+# Locations can either come from nodes directly or from location fields on
+# nodes. For example, a `ClassNode` has an overall location encompassing the
+# entire class, but it also has a location for the `class` keyword.
+#
+# Once the nearest locations are found, it determines which one to attach
+# to. If it's a trailing comment (a comment on the same line as other source
+# code), it will favor attaching to the nearest location that occurs before
+# the comment. Otherwise it will favor attaching to the nearest location
+# that is after the comment.
+#
+# source://prism-0.20.0/lib/prism/parse_result/comments.rb:19
+class Prism::ParseResult::Comments
+  # Create a new Comments object that will attach comments to the given
+  # parse result.
+  #
+  # @return [Comments] a new instance of Comments
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:78
+  def initialize(parse_result); end
+
+  # Attach the comments to their respective locations in the tree by
+  # mutating the parse result.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:84
+  def attach!; end
+
+  # The parse result that we are attaching comments to.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:74
+  def parse_result; end
+
+  private
+
+  # Responsible for finding the nearest targets to the given comment within
+  # the context of the given encapsulating node.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:103
+  def nearest_targets(node, comment); end
+end
+
+# A target for attaching comments that is based on a location field on a
+# node. For example, the `end` token of a ClassNode.
+#
+# source://prism-0.20.0/lib/prism/parse_result/comments.rb:49
+class Prism::ParseResult::Comments::LocationTarget
+  # @return [LocationTarget] a new instance of LocationTarget
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:52
+  def initialize(location); end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:68
+  def <<(comment); end
+
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:64
+  def encloses?(comment); end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:60
+  def end_offset; end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:50
+  def location; end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:56
+  def start_offset; end
+end
+
+# A target for attaching comments that is based on a specific node's
+# location.
+#
+# source://prism-0.20.0/lib/prism/parse_result/comments.rb:22
+class Prism::ParseResult::Comments::NodeTarget
+  # @return [NodeTarget] a new instance of NodeTarget
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:25
+  def initialize(node); end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:42
+  def <<(comment); end
+
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:37
+  def encloses?(comment); end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:33
+  def end_offset; end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:23
+  def node; end
+
+  # source://prism-0.20.0/lib/prism/parse_result/comments.rb:29
+  def start_offset; end
+end
+
+# The :line tracepoint event gets fired whenever the Ruby VM encounters an
+# expression on a new line. The types of expressions that can trigger this
+# event are:
+#
+# * if statements
+# * unless statements
+# * nodes that are children of statements lists
+#
+# In order to keep track of the newlines, we have a list of offsets that
+# come back from the parser. We assign these offsets to the first nodes that
+# we find in the tree that are on those lines.
+#
+# Note that the logic in this file should be kept in sync with the Java
+# MarkNewlinesVisitor, since that visitor is responsible for marking the
+# newlines for JRuby/TruffleRuby.
+#
+# source://prism-0.20.0/lib/prism/parse_result/newlines.rb:21
+class Prism::ParseResult::Newlines < ::Prism::Visitor
+  # Create a new Newlines visitor with the given newline offsets.
+  #
+  # @return [Newlines] a new instance of Newlines
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:22
+  def initialize(newline_marked); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:27
+  def visit_block_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:41
+  def visit_if_node(node); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:27
+  def visit_lambda_node(node); end
+
+  # Permit statements lists to mark newlines within themselves.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:49
+  def visit_statements_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result/newlines.rb:41
+  def visit_unless_node(node); end
+end
+
+# This represents a warning that was encountered during parsing.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:337
+class Prism::ParseWarning
+  # Create a new warning object with the given message and location.
+  #
+  # @return [ParseWarning] a new instance of ParseWarning
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:348
+  def initialize(message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseWarning.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:355
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this warning.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:360
+  def inspect; end
+
+  # The level of this warning.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:345
+  def level; end
+
+  # A Location object representing the location of this warning in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:342
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this warning.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:339
+  sig { returns(String) }
+  def message; end
+end
+
+# A pattern is an object that wraps a Ruby pattern matching expression. The
+# expression would normally be passed to an `in` clause within a `case`
+# expression or a rightward assignment expression. For example, in the
+# following snippet:
+#
+#     case node
+#     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
+#     end
+#
+# the pattern is the <tt>ConstantPathNode[...]</tt> expression.
+#
+# The pattern gets compiled into an object that responds to #call by running
+# the #compile method. This method itself will run back through Prism to
+# parse the expression into a tree, then walk the tree to generate the
+# necessary callable objects. For example, if you wanted to compile the
+# expression above into a callable, you would:
+#
+#     callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
+#     callable.call(node)
+#
+# The callable object returned by #compile is guaranteed to respond to #call
+# with a single argument, which is the node to match against. It also is
+# guaranteed to respond to #===, which means it itself can be used in a `case`
+# expression, as in:
+#
+#     case node
+#     when callable
+#     end
+#
+# If the query given to the initializer cannot be compiled into a valid
+# matcher (either because of a syntax error or because it is using syntax we
+# do not yet support) then a Prism::Pattern::CompilationError will be
+# raised.
+#
+# source://prism-0.20.0/lib/prism/pattern.rb:37
+class Prism::Pattern
+  # Create a new pattern with the given query. The query should be a string
+  # containing a Ruby pattern matching expression.
+  #
+  # @return [Pattern] a new instance of Pattern
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:63
+  def initialize(query); end
+
+  # Compile the query into a callable object that can be used to match against
+  # nodes.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:70
+  def compile; end
+
+  # The query that this pattern was initialized with.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:59
+  def query; end
+
+  # Scan the given node and all of its children for nodes that match the
+  # pattern. If a block is given, it will be called with each node that
+  # matches the pattern. If no block is given, an enumerator will be returned
+  # that will yield each node that matches the pattern.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:79
+  def scan(root); end
+
+  private
+
+  # Shortcut for combining two procs into one that returns true if both return
+  # true.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:95
+  def combine_and(left, right); end
+
+  # Shortcut for combining two procs into one that returns true if either
+  # returns true.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:101
+  def combine_or(left, right); end
+
+  # in foo | bar
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:136
+  def compile_alternation_pattern_node(node); end
+
+  # in [foo, bar, baz]
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:111
+  def compile_array_pattern_node(node); end
+
+  # in Prism::ConstantReadNode
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:141
+  def compile_constant_path_node(node); end
+
+  # in ConstantReadNode
+  # in String
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:153
+  def compile_constant_read_node(node); end
+
+  # Raise an error because the given node is not supported.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:106
+  def compile_error(node); end
+
+  # in InstanceVariableReadNode[name: Symbol]
+  # in { name: Symbol }
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:171
+  def compile_hash_pattern_node(node); end
+
+  # in nil
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:196
+  def compile_nil_node(node); end
+
+  # Compile any kind of node. Dispatch out to the individual compilation
+  # methods based on the type of node.
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:225
+  def compile_node(node); end
+
+  # in /foo/
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:201
+  def compile_regular_expression_node(node); end
+
+  # in ""
+  # in "foo"
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:209
+  def compile_string_node(node); end
+
+  # in :+
+  # in :foo
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:217
+  def compile_symbol_node(node); end
+end
+
+# Raised when the query given to a pattern is either invalid Ruby syntax or
+# is using syntax that we don't yet support.
+#
+# source://prism-0.20.0/lib/prism/pattern.rb:42
+class Prism::Pattern::CompilationError < ::StandardError
+  # Create a new CompilationError with the given representation of the node
+  # that caused the error.
+  #
+  # @return [CompilationError] a new instance of CompilationError
+  #
+  # source://prism-0.20.0/lib/prism/pattern.rb:43
+  def initialize(repr); end
+end
+
+# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
+#
+#     foo in ^(bar)
+#            ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:13658
+class Prism::PinnedExpressionNode < ::Prism::Node
+  # def initialize: (Node expression, Location operator_loc, Location lparen_loc, Location rparen_loc, Location location) -> void
+  #
+  # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13671
+  def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13680
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13685
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13695
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13690
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> PinnedExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13700
+  sig { params(params: T.untyped).returns(Prism::PinnedExpressionNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13685
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13714
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13659
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13734
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def lparen: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13724
+  sig { returns(String) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13665
+  sig { returns(Prism::Location) }
+  def lparen_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13719
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13662
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def rparen: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13729
+  sig { returns(String) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13668
+  sig { returns(Prism::Location) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13758
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13768
+    def type; end
+  end
+end
+
+# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
+#
+#     foo in ^bar
+#            ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:13778
+class Prism::PinnedVariableNode < ::Prism::Node
+  # def initialize: (Node variable, Location operator_loc, Location location) -> void
+  #
+  # @return [PinnedVariableNode] a new instance of PinnedVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13785
+  def initialize(variable, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13792
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13797
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13807
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13802
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> PinnedVariableNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13812
+  sig { params(params: T.untyped).returns(Prism::PinnedVariableNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13797
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { variable: Node, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13824
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13834
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13829
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13782
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13856
+  def type; end
+
+  # attr_reader variable: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13779
+  sig { returns(Prism::Node) }
+  def variable; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13866
+    def type; end
+  end
+end
+
+# Represents the use of the `END` keyword.
+#
+#     END { foo }
+#     ^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:13876
+class Prism::PostExecutionNode < ::Prism::Node
+  # def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+  #
+  # @return [PostExecutionNode] a new instance of PostExecutionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13889
+  def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13898
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13903
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13949
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13886
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13915
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13908
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> PostExecutionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13920
+  sig { params(params: T.untyped).returns(Prism::PostExecutionNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13903
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13934
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13954
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13939
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13880
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13944
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13883
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13877
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:13982
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:13992
+    def type; end
+  end
+end
+
+# Represents the use of the `BEGIN` keyword.
+#
+#     BEGIN { foo }
+#     ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14002
+class Prism::PreExecutionNode < ::Prism::Node
+  # def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+  #
+  # @return [PreExecutionNode] a new instance of PreExecutionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14015
+  def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14024
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14029
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14075
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14012
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14041
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14034
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> PreExecutionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14046
+  sig { params(params: T.untyped).returns(Prism::PreExecutionNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14029
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14060
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14080
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14065
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14006
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14070
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14009
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14003
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14108
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14118
+    def type; end
+  end
+end
+
+# The top level node of any parse tree.
+#
+# source://prism-0.20.0/lib/prism/node.rb:14125
+class Prism::ProgramNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, StatementsNode statements, Location location) -> void
+  #
+  # @return [ProgramNode] a new instance of ProgramNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14132
+  def initialize(locals, statements, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14139
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14144
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14154
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14149
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ProgramNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14159
+  sig { params(params: T.untyped).returns(Prism::ProgramNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14144
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], statements: StatementsNode, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14171
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14176
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14126
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # attr_reader statements: StatementsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14129
+  sig { returns(Prism::StatementsNode) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14198
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14208
+    def type; end
+  end
+end
+
+# Flags for range and flip-flop nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17620
+module Prism::RangeFlags; end
+
+# ... operator
+#
+# source://prism-0.20.0/lib/prism/node.rb:17622
+Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer)
+
+# Represents the use of the `..` or `...` operators.
+#
+#     1..2
+#     ^^^^
+#
+#     c if a =~ /left/ ... b =~ /right/
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14221
+class Prism::RangeNode < ::Prism::Node
+  # def initialize: (Integer flags, Node? left, Node? right, Location operator_loc, Location location) -> void
+  #
+  # @return [RangeNode] a new instance of RangeNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14247
+  def initialize(flags, left, right, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14256
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14261
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14274
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14266
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RangeNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14279
+  sig { params(params: T.untyped).returns(Prism::RangeNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14261
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14293
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14298
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14308
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     1...
+  #     ^
+  #
+  #     hello...goodbye
+  #     ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14231
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14303
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `..` or `...` operator.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14244
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     ..5
+  #       ^
+  #
+  #     1...foo
+  #         ^^^
+  # If neither right-hand or left-hand side was included, this will be a MissingNode.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14241
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14342
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14222
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14352
+    def type; end
+  end
+end
+
+# Represents a rational number literal.
+#
+#     1.0r
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14362
+class Prism::RationalNode < ::Prism::Node
+  # def initialize: (Node numeric, Location location) -> void
+  #
+  # @return [RationalNode] a new instance of RationalNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14366
+  def initialize(numeric, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14372
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14377
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14387
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14382
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RationalNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14392
+  sig { params(params: T.untyped).returns(Prism::RationalNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14377
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14403
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14408
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader numeric: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14363
+  sig { returns(Prism::Node) }
+  def numeric; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14429
+  def type; end
+
+  # Returns the value of the node as a Ruby Rational.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:83
+  def value; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14439
+    def type; end
+  end
+end
+
+# Represents the use of the `redo` keyword.
+#
+#     redo
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14449
+class Prism::RedoNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [RedoNode] a new instance of RedoNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14450
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14455
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14460
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14470
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14465
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RedoNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14475
+  sig { params(params: T.untyped).returns(Prism::RedoNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14460
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14485
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14490
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14509
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14519
+    def type; end
+  end
+end
+
+# Flags for regular expression and match last line nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17626
+module Prism::RegularExpressionFlags; end
+
+# n - forces the ASCII-8BIT encoding
+#
+# source://prism-0.20.0/lib/prism/node.rb:17643
+Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
+
+# e - forces the EUC-JP encoding
+#
+# source://prism-0.20.0/lib/prism/node.rb:17640
+Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer)
+
+# x - ignores whitespace and allows comments in regular expressions
+#
+# source://prism-0.20.0/lib/prism/node.rb:17631
+Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to binary
+#
+# source://prism-0.20.0/lib/prism/node.rb:17655
+Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+#
+# source://prism-0.20.0/lib/prism/node.rb:17658
+Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism-0.20.0/lib/prism/node.rb:17652
+Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# i - ignores the case of characters when matching
+#
+# source://prism-0.20.0/lib/prism/node.rb:17628
+Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer)
+
+# m - allows $ to match the end of lines within strings
+#
+# source://prism-0.20.0/lib/prism/node.rb:17634
+Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer)
+
+# o - only interpolates values into the regular expression once
+#
+# source://prism-0.20.0/lib/prism/node.rb:17637
+Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
+
+# u - forces the UTF-8 encoding
+#
+# source://prism-0.20.0/lib/prism/node.rb:17649
+Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
+
+# s - forces the Windows-31J encoding
+#
+# source://prism-0.20.0/lib/prism/node.rb:17646
+Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer)
+
+# Represents a regular expression literal with no interpolation.
+#
+#     /foo/i
+#     ^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14529
+class Prism::RegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+  #
+  # @return [RegularExpressionNode] a new instance of RegularExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14545
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14555
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14620
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14560
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14660
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14539
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14570
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14565
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14655
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14536
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (**params) -> RegularExpressionNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14575
+  sig { params(params: T.untyped).returns(Prism::RegularExpressionNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14560
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14590
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14615
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14600
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14640
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14645
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14635
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14595
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14665
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14605
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14610
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14650
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14533
+  sig { returns(Prism::Location) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14690
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14542
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14630
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14625
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14530
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14700
+    def type; end
+  end
+end
+
+# source://prism-0.20.0/lib/prism/node_ext.rb:6
+module Prism::RegularExpressionOptions
+  # Returns a numeric value that represents the flags that were used to create
+  # the regular expression.
+  #
+  # source://prism-0.20.0/lib/prism/node_ext.rb:9
+  def options; end
+end
+
+# Represents a required keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: )
+#           ^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:14711
+class Prism::RequiredKeywordParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol name, Location name_loc, Location location) -> void
+  #
+  # @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14721
+  def initialize(flags, name, name_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14729
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14734
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14744
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14739
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RequiredKeywordParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14749
+  sig { params(params: T.untyped).returns(Prism::RequiredKeywordParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14734
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14762
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14772
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14715
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14718
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14767
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14795
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14712
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14805
+    def type; end
+  end
+end
+
+# Represents a required parameter to a method, block, or lambda definition.
+#
+#     def a(b)
+#           ^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:14816
+class Prism::RequiredParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol name, Location location) -> void
+  #
+  # @return [RequiredParameterNode] a new instance of RequiredParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14823
+  def initialize(flags, name, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14830
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14835
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14845
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14840
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RequiredParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14850
+  sig { params(params: T.untyped).returns(Prism::RequiredParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14835
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14862
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14872
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14820
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14867
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14894
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14817
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:14904
+    def type; end
+  end
+end
+
+# Represents an expression modified with a rescue.
+#
+#     foo rescue nil
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:14914
+class Prism::RescueModifierNode < ::Prism::Node
+  # def initialize: (Node expression, Location keyword_loc, Node rescue_expression, Location location) -> void
+  #
+  # @return [RescueModifierNode] a new instance of RescueModifierNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14924
+  def initialize(expression, keyword_loc, rescue_expression, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14932
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14941
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14951
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14946
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RescueModifierNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14956
+  sig { params(params: T.untyped).returns(Prism::RescueModifierNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14941
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14969
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14915
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14979
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14974
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14918
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader rescue_expression: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:14921
+  sig { returns(Prism::Node) }
+  def rescue_expression; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:14936
+  def set_newline_flag(newline_marked); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15003
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15013
+    def type; end
+  end
+end
+
+# Represents a rescue statement.
+#
+#     begin
+#     rescue Foo, *splat, Bar => ex
+#       foo
+#     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#     end
+#
+# `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
+#
+# source://prism-0.20.0/lib/prism/node.rb:15028
+class Prism::RescueNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, Array[Node] exceptions, Location? operator_loc, Node? reference, StatementsNode? statements, RescueNode? consequent, Location location) -> void
+  #
+  # @return [RescueNode] a new instance of RescueNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15047
+  def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15058
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15078
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15068
+  def compact_child_nodes; end
+
+  # attr_reader consequent: RescueNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15044
+  sig { returns(T.nilable(Prism::RescueNode)) }
+  def consequent; end
+
+  # def copy: (**params) -> RescueNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15083
+  sig { params(params: T.untyped).returns(Prism::RescueNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15099
+  def deconstruct_keys(keys); end
+
+  # attr_reader exceptions: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15032
+  sig { returns(T::Array[Prism::Node]) }
+  def exceptions; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15114
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15104
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15029
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def operator: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15109
+  sig { returns(T.nilable(String)) }
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15035
+  sig { returns(T.nilable(Prism::Location)) }
+  def operator_loc; end
+
+  # attr_reader reference: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15038
+  sig { returns(T.nilable(Prism::Node)) }
+  def reference; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15041
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15154
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15164
+    def type; end
+  end
+end
+
+# Represents a rest parameter to a method, block, or lambda definition.
+#
+#     def a(*b)
+#           ^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:15175
+class Prism::RestParameterNode < ::Prism::Node
+  # def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+  #
+  # @return [RestParameterNode] a new instance of RestParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15188
+  def initialize(flags, name, name_loc, operator_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15197
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15202
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15212
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15207
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RestParameterNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15217
+  sig { params(params: T.untyped).returns(Prism::RestParameterNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15202
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15231
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15246
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader name: Symbol?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15179
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15182
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15241
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15185
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15236
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15274
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15176
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15284
+    def type; end
+  end
+end
+
+# Represents the use of the `retry` keyword.
+#
+#     retry
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15294
+class Prism::RetryNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [RetryNode] a new instance of RetryNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15295
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15300
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15305
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15315
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15310
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> RetryNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15320
+  sig { params(params: T.untyped).returns(Prism::RetryNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15305
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15330
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15335
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15354
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15364
+    def type; end
+  end
+end
+
+# Represents the use of the `return` keyword.
+#
+#     return 1
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15374
+class Prism::ReturnNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
+  #
+  # @return [ReturnNode] a new instance of ReturnNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15381
+  def initialize(keyword_loc, arguments, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15388
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15378
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15393
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15405
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15398
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> ReturnNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15410
+  sig { params(params: T.untyped).returns(Prism::ReturnNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15393
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15422
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15432
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15427
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15375
+  sig { returns(Prism::Location) }
+  def keyword_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15458
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15468
+    def type; end
+  end
+end
+
+# Note: This integration is not finished, and therefore still has many
+# inconsistencies with Ripper. If you'd like to help out, pull requests would
+# be greatly appreciated!
+#
+# This class is meant to provide a compatibility layer between prism and
+# Ripper. It functions by parsing the entire tree first and then walking it
+# and executing each of the Ripper callbacks as it goes.
+#
+# This class is going to necessarily be slower than the native Ripper API. It
+# is meant as a stopgap until developers migrate to using prism. It is also
+# meant as a test harness for the prism parser.
+#
+# To use this class, you treat `Prism::RipperCompat` effectively as you would
+# treat the `Ripper` class.
+#
+# source://prism-0.20.0/lib/prism/ripper_compat.rb:22
+class Prism::RipperCompat < ::Prism::Visitor
+  # Create a new RipperCompat object with the given source.
+  #
+  # @return [RipperCompat] a new instance of RipperCompat
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:74
+  def initialize(source); end
+
+  # The current column number of the parser.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:71
+  def column; end
+
+  # True if the parser encountered an error during parsing.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:86
+  def error?; end
+
+  # The current line number of the parser.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:68
+  def lineno; end
+
+  # Parse the source and return the result.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:91
+  def parse; end
+
+  # The source that is being parsed.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:65
+  def source; end
+
+  # Visit a CallNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:110
+  def visit_call_node(node); end
+
+  # Visit a FloatNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:123
+  def visit_float_node(node); end
+
+  # Visit a ImaginaryNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:129
+  def visit_imaginary_node(node); end
+
+  # Visit an IntegerNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:135
+  def visit_integer_node(node); end
+
+  # Visit a ProgramNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:155
+  def visit_program_node(node); end
+
+  # Visit a RationalNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:141
+  def visit_rational_node(node); end
+
+  # Visit a StatementsNode node.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:147
+  def visit_statements_node(node); end
+
+  private
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def _dispatch0; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def _dispatch1(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def _dispatch2(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def _dispatch3(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def _dispatch4(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:197
+  def _dispatch5(_, _, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:198
+  def _dispatch7(_, _, _, _, _, _, _); end
+
+  # This method is responsible for updating lineno and column information
+  # to reflect the current node.
+  #
+  # This method could be drastically improved with some caching on the start
+  # of every line, but for now it's good enough.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:182
+  def bounds(location); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_BEGIN(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_CHAR(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_END(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on___end__(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_alias(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_alias_error(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_aref(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_aref_field(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_arg_ambiguous(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_arg_paren(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_args_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_args_add_block(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_args_add_star(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_args_forward; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_args_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_array(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def on_aryptn(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_assign(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_assign_error(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_assoc_new(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_assoc_splat(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_assoclist_from_args(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_backref(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_backtick(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_bare_assoc_hash(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_begin(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_binary(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_block_var(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_blockarg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def on_bodystmt(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_brace_block(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_break(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_call(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_case(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_class(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_class_name_error(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_comma(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_command(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def on_command_call(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_comment(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_const(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_const_path_field(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_const_path_ref(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_const_ref(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_cvar(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_def(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_defined(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:197
+  def on_defs(_, _, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_do_block(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_dot2(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_dot3(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_dyna_symbol(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_else(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_elsif(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embdoc(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embdoc_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embdoc_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embexpr_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embexpr_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_embvar(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_ensure(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_excessed_comma; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_fcall(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_field(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_float(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def on_fndptn(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_for(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_gvar(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_hash(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_heredoc_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_heredoc_dedent(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_heredoc_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_hshptn(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_ident(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_if(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_if_mod(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_ifop(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_ignored_nl(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_ignored_sp(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_imaginary(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_in(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_int(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_ivar(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_kw(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_kwrest_param(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_label(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_label_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_lambda(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_lbrace(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_lbracket(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_lparen(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_magic_comment(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_massign(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_method_add_arg(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_method_add_block(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_mlhs_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_mlhs_add_post(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_mlhs_add_star(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_mlhs_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_mlhs_paren(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_module(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_mrhs_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_mrhs_add_star(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_mrhs_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_mrhs_new_from_args(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_next(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_nl(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_nokw_param(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_op(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_opassign(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_operator_ambiguous(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_param_error(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:198
+  def on_params(_, _, _, _, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_paren(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_parse_error(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_period(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_program(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_qsymbols_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_qsymbols_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_qsymbols_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_qwords_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_qwords_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_qwords_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_rational(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_rbrace(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_rbracket(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_redo; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_regexp_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_regexp_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_regexp_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_regexp_literal(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_regexp_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:196
+  def on_rescue(_, _, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_rescue_mod(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_rest_param(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_retry; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_return(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_return0; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_rparen(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_sclass(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_semicolon(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_sp(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_stmts_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_stmts_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_string_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_string_concat(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_string_content; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_string_dvar(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_string_embexpr(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_string_literal(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_super(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_symbeg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_symbol(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_symbol_literal(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_symbols_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_symbols_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_symbols_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_tlambda(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_tlambeg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_top_const_field(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_top_const_ref(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_tstring_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_tstring_content(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_tstring_end(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_unary(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_undef(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_unless(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_unless_mod(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_until(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_until_mod(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_var_alias(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_var_field(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_var_ref(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_vcall(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_void_stmt; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:195
+  def on_when(_, _, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_while(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_while_mod(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_word_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_word_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_words_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_words_beg(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_words_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_words_sep(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:194
+  def on_xstring_add(_, _); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_xstring_literal(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_xstring_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:193
+  def on_yield(_); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_yield0; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:192
+  def on_zsuper; end
+
+  # Lazily initialize the parse result.
+  #
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:188
+  def result; end
+
+  class << self
+    # This is a convenience method that runs the SexpBuilderPP subclass parser.
+    #
+    # source://prism-0.20.0/lib/prism/ripper_compat.rb:171
+    def sexp(source); end
+
+    # This is a convenience method that runs the SexpBuilder subclass parser.
+    #
+    # source://prism-0.20.0/lib/prism/ripper_compat.rb:166
+    def sexp_raw(source); end
+  end
+end
+
+# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+# returns the arrays of [type, *children].
+#
+# source://prism-0.20.0/lib/prism/ripper_compat.rb:23
+class Prism::RipperCompat::SexpBuilder < ::Prism::RipperCompat
+  private
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_BEGIN(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_CHAR(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_END(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on___end__(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_alias(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_alias_error(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_aref(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_aref_field(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_arg_ambiguous(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_arg_paren(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_args_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_args_add_block(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_args_add_star(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_args_forward(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_args_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_array(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_aryptn(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_assign(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_assign_error(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_assoc_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_assoc_splat(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_assoclist_from_args(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_backref(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_backtick(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_bare_assoc_hash(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_begin(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_binary(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_block_var(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_blockarg(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_bodystmt(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_brace_block(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_break(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_call(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_case(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_class(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_class_name_error(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_comma(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_command(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_command_call(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_comment(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_const(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_const_path_field(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_const_path_ref(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_const_ref(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_cvar(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_def(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_defined(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_defs(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_do_block(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_dot2(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_dot3(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_dyna_symbol(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_else(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_elsif(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embdoc(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embdoc_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embdoc_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embexpr_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embexpr_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_embvar(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_ensure(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_excessed_comma(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_fcall(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_field(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_float(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_fndptn(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_for(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_gvar(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_hash(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_heredoc_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_heredoc_dedent(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_heredoc_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_hshptn(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_ident(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_if(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_if_mod(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_ifop(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_ignored_nl(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_ignored_sp(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_imaginary(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_in(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_int(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_ivar(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_kw(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_kwrest_param(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_label(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_label_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_lambda(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_lbrace(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_lbracket(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_lparen(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_magic_comment(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_massign(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_method_add_arg(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_method_add_block(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mlhs_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mlhs_add_post(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mlhs_add_star(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mlhs_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mlhs_paren(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_module(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mrhs_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mrhs_add_star(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mrhs_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_mrhs_new_from_args(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_next(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_nl(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_nokw_param(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_op(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_opassign(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_operator_ambiguous(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_param_error(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_params(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_paren(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_parse_error(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_period(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_program(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_qsymbols_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_qsymbols_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_qsymbols_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_qwords_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_qwords_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_qwords_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_rational(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_rbrace(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_rbracket(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_redo(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_regexp_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_regexp_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_regexp_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_regexp_literal(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_regexp_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_rescue(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_rescue_mod(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_rest_param(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_retry(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_return(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_return0(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_rparen(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_sclass(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_semicolon(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_sp(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_stmts_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_stmts_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_concat(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_content(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_dvar(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_embexpr(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_string_literal(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_super(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_symbeg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_symbol(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_symbol_literal(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_symbols_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_symbols_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_symbols_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_tlambda(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_tlambeg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_top_const_field(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_top_const_ref(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_tstring_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_tstring_content(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_tstring_end(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_unary(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_undef(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_unless(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_unless_mod(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_until(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_until_mod(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_var_alias(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_var_field(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_var_ref(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_vcall(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_void_stmt(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_when(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_while(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_while_mod(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_word_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_word_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_words_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_words_beg(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_words_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:33
+  def on_words_sep(value); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_xstring_add(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_xstring_literal(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_xstring_new(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_yield(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_yield0(*args); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:27
+  def on_zsuper(*args); end
+end
+
+# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
+# returns the same values as ::Ripper::SexpBuilder except with a couple of
+# niceties that flatten linked lists into arrays.
+#
+# source://prism-0.20.0/lib/prism/ripper_compat.rb:42
+class Prism::RipperCompat::SexpBuilderPP < ::Prism::RipperCompat::SexpBuilder
+  private
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def _dispatch_event_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def _dispatch_event_push(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_args_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_args_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_mlhs_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_mlhs_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_mrhs_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_mrhs_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_qsymbols_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_qsymbols_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_qwords_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_qwords_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_regexp_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_regexp_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_stmts_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_stmts_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_string_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_symbols_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_symbols_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_word_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_word_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_words_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_words_new; end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:49
+  def on_xstring_add(list, item); end
+
+  # source://prism-0.20.0/lib/prism/ripper_compat.rb:45
+  def on_xstring_new; end
+end
+
+# Represents the `self` keyword.
+#
+#     self
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15478
+class Prism::SelfNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [SelfNode] a new instance of SelfNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15479
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15484
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15489
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15499
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15494
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SelfNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15504
+  sig { params(params: T.untyped).returns(Prism::SelfNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15489
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15514
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15519
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15538
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15548
+    def type; end
+  end
+end
+
+# A module responsible for deserializing parse results.
+#
+# source://prism-0.20.0/lib/prism/serialize.rb:23
+module Prism::Serialize
+  class << self
+    # Deserialize the AST represented by the given string into a parse result.
+    #
+    # source://prism-0.20.0/lib/prism/serialize.rb:37
+    def load(input, serialized); end
+
+    # Deserialize the tokens represented by the given string into a parse
+    # result.
+    #
+    # source://prism-0.20.0/lib/prism/serialize.rb:49
+    def load_tokens(source, serialized); end
+  end
+end
+
+# source://prism-0.20.0/lib/prism/serialize.rb:53
+class Prism::Serialize::Loader
+  # @return [Loader] a new instance of Loader
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:58
+  def initialize(source, serialized); end
+
+  # Returns the value of attribute constant_pool.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:55
+  def constant_pool; end
+
+  # Returns the value of attribute constant_pool_offset.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:55
+  def constant_pool_offset; end
+
+  # Returns the value of attribute encoding.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:54
+  def encoding; end
+
+  # Returns the value of attribute input.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:54
+  def input; end
+
+  # Returns the value of attribute io.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:54
+  def io; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:92
+  def load_comments; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:82
+  def load_encoding; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:73
+  def load_header; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:102
+  def load_metadata; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:135
+  def load_nodes; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:148
+  def load_result; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:88
+  def load_start_line; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:111
+  def load_tokens; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:124
+  def load_tokens_result; end
+
+  # Returns the value of attribute serialized.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:54
+  def serialized; end
+
+  # Returns the value of attribute source.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:55
+  def source; end
+
+  # Returns the value of attribute start_line.
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:56
+  def start_line; end
+
+  private
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:211
+  def load_constant(index); end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:187
+  def load_embedded_string; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:241
+  def load_error_level; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:203
+  def load_location; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:266
+  def load_node; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:236
+  def load_optional_constant; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:207
+  def load_optional_location; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:180
+  def load_optional_node; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:232
+  def load_required_constant; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:176
+  def load_serialized_length; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:191
+  def load_string; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:171
+  def load_varsint; end
+
+  # variable-length integer using https://en.wikipedia.org/wiki/LEB128
+  # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
+  #
+  # source://prism-0.20.0/lib/prism/serialize.rb:157
+  def load_varuint; end
+
+  # source://prism-0.20.0/lib/prism/serialize.rb:252
+  def load_warning_level; end
+end
+
+# The major version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism-0.20.0/lib/prism/serialize.rb:26
+Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The minor version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism-0.20.0/lib/prism/serialize.rb:30
+Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The patch version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism-0.20.0/lib/prism/serialize.rb:34
+Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The token types that can be indexed by their enum values.
+#
+# source://prism-0.20.0/lib/prism/serialize.rb:1178
+Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# Represents a singleton class declaration involving the `class` keyword.
+#
+#     class << self end
+#     ^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15558
+class Prism::SingletonClassNode < ::Prism::Node
+  # def initialize: (Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Node expression, Node? body, Location end_keyword_loc, Location location) -> void
+  #
+  # @return [SingletonClassNode] a new instance of SingletonClassNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15577
+  def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15588
+  def accept(visitor); end
+
+  # attr_reader body: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15571
+  sig { returns(T.nilable(Prism::Node)) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15593
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15632
+  sig { returns(String) }
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15562
+  sig { returns(Prism::Location) }
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15606
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15598
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SingletonClassNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15611
+  sig { params(params: T.untyped).returns(Prism::SingletonClassNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15593
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15627
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15642
+  sig { returns(String) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15574
+  sig { returns(Prism::Location) }
+  def end_keyword_loc; end
+
+  # attr_reader expression: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15568
+  sig { returns(Prism::Node) }
+  def expression; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15647
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # attr_reader locals: Array[Symbol]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15559
+  sig { returns(T::Array[Symbol]) }
+  def locals; end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15637
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15565
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15678
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15688
+    def type; end
+  end
+end
+
+# This represents a source of Ruby code that has been parsed. It is used in
+# conjunction with locations to allow them to resolve line numbers and source
+# ranges.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:7
+class Prism::Source
+  # Create a new source object with the given source code and newline byte
+  # offsets. If no newline byte offsets are given, they will be computed from
+  # the source code.
+  #
+  # @return [Source] a new instance of Source
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:20
+  def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+
+  # Return the column number in characters for the given byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:55
+  def character_column(byte_offset); end
+
+  # Return the character offset for the given byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:50
+  def character_offset(byte_offset); end
+
+  # Return the column number for the given byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:45
+  def column(byte_offset); end
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:34
+  def line(byte_offset); end
+
+  sig { params(value: Integer).returns(Integer) }
+  def line_offset(value); end
+
+  # Return the byte offset of the start of the line corresponding to the given
+  # byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:40
+  def line_start(byte_offset); end
+
+  # The list of newline byte offsets in the source code.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:15
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+
+  # Perform a byteslice on the source code using the given byte offset and
+  # byte length.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:28
+  def slice(byte_offset, length); end
+
+  # The source code that this source object represents.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:9
+  sig { returns(String) }
+  def source; end
+
+  # The line number where this source starts.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:12
+  def start_line; end
+
+  # The line number where this source starts.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:12
+  def start_line=(_arg0); end
+
+  private
+
+  # Find all of the newlines in the source code and return their byte offsets
+  # from the start of the string an array.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:83
+  def compute_offsets(code); end
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:63
+  def find_line(byte_offset); end
+end
+
+# Represents the use of the `__ENCODING__` keyword.
+#
+#     __ENCODING__
+#     ^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15698
+class Prism::SourceEncodingNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [SourceEncodingNode] a new instance of SourceEncodingNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15699
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15704
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15709
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15719
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15714
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SourceEncodingNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15724
+  sig { params(params: T.untyped).returns(Prism::SourceEncodingNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15709
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15734
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15739
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15758
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15768
+    def type; end
+  end
+end
+
+# Represents the use of the `__FILE__` keyword.
+#
+#     __FILE__
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15778
+class Prism::SourceFileNode < ::Prism::Node
+  # def initialize: (String filepath, Location location) -> void
+  #
+  # @return [SourceFileNode] a new instance of SourceFileNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15782
+  def initialize(filepath, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15788
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15793
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15803
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15798
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SourceFileNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15808
+  sig { params(params: T.untyped).returns(Prism::SourceFileNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15793
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { filepath: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15819
+  def deconstruct_keys(keys); end
+
+  # attr_reader filepath: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15779
+  sig { returns(String) }
+  def filepath; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15824
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15844
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15854
+    def type; end
+  end
+end
+
+# Represents the use of the `__LINE__` keyword.
+#
+#     __LINE__
+#     ^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15864
+class Prism::SourceLineNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [SourceLineNode] a new instance of SourceLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15865
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15870
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15875
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15885
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15880
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SourceLineNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15890
+  sig { params(params: T.untyped).returns(Prism::SourceLineNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15875
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15900
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15905
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15924
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:15934
+    def type; end
+  end
+end
+
+# Represents the use of the splat operator.
+#
+#     [*a]
+#      ^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:15944
+class Prism::SplatNode < ::Prism::Node
+  # def initialize: (Location operator_loc, Node? expression, Location location) -> void
+  #
+  # @return [SplatNode] a new instance of SplatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15951
+  def initialize(operator_loc, expression, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15958
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15963
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15975
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15968
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SplatNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15980
+  sig { params(params: T.untyped).returns(Prism::SplatNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15963
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, expression: Node?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15992
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15948
+  sig { returns(T.nilable(Prism::Node)) }
+  def expression; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16002
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def operator: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15997
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:15945
+  sig { returns(Prism::Location) }
+  def operator_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16028
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16038
+    def type; end
+  end
+end
+
+# Represents a set of statements contained within some scope.
+#
+#     foo; bar; baz
+#     ^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16048
+class Prism::StatementsNode < ::Prism::Node
+  # def initialize: (Array[Node] body, Location location) -> void
+  #
+  # @return [StatementsNode] a new instance of StatementsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16052
+  def initialize(body, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16058
+  def accept(visitor); end
+
+  # attr_reader body: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16049
+  sig { returns(T::Array[Prism::Node]) }
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16073
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16068
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> StatementsNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16078
+  sig { params(params: T.untyped).returns(Prism::StatementsNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { body: Array[Node], location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16089
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16094
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16114
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16124
+    def type; end
+  end
+end
+
+# Flags for string nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17662
+module Prism::StringFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism-0.20.0/lib/prism/node.rb:17667
+Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism-0.20.0/lib/prism/node.rb:17664
+Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# frozen by virtue of a `frozen_string_literal` comment
+#
+# source://prism-0.20.0/lib/prism/node.rb:17670
+Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+
+# Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
+#
+#     "foo"
+#     ^^^^^
+#
+#     %w[foo]
+#        ^^^
+#
+#     "foo #{bar} baz"
+#      ^^^^      ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16140
+class Prism::StringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # def initialize: (Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped, Location location) -> void
+  #
+  # @return [StringNode] a new instance of StringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16156
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16166
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16171
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16231
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16150
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16181
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16176
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16226
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16147
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (**params) -> StringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16186
+  sig { params(params: T.untyped).returns(Prism::StringNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16171
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16201
+  def deconstruct_keys(keys); end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16211
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16206
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16216
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16236
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16221
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16144
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16261
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16153
+  sig { returns(String) }
+  def unescaped; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16141
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16271
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword with parentheses or arguments.
+#
+#     super()
+#     ^^^^^^^
+#
+#     super foo, bar
+#     ^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16284
+class Prism::SuperNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Node? block, Location location) -> void
+  #
+  # @return [SuperNode] a new instance of SuperNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16300
+  def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16310
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16291
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # attr_reader block: Node?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16297
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16315
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16328
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16320
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SuperNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16333
+  sig { params(params: T.untyped).returns(Prism::SuperNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16315
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16348
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16368
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16353
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16285
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16358
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16288
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16363
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16294
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16402
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16412
+    def type; end
+  end
+end
+
+# Flags for symbol nodes.
+#
+# source://prism-0.20.0/lib/prism/node.rb:17674
+module Prism::SymbolFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism-0.20.0/lib/prism/node.rb:17679
+Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+#
+# source://prism-0.20.0/lib/prism/node.rb:17682
+Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+#
+# source://prism-0.20.0/lib/prism/node.rb:17676
+Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# Represents a symbol literal or a symbol contained within a `%i` list.
+#
+#     :foo
+#     ^^^^
+#
+#     %i[foo]
+#        ^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16425
+class Prism::SymbolNode < ::Prism::Node
+  # def initialize: (Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped, Location location) -> void
+  #
+  # @return [SymbolNode] a new instance of SymbolNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16441
+  def initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16451
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16516
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16435
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16466
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16461
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> SymbolNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16471
+  sig { params(params: T.untyped).returns(Prism::SymbolNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16486
+  def deconstruct_keys(keys); end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16496
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16501
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16491
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16521
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16506
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16429
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16546
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16438
+  sig { returns(String) }
+  def unescaped; end
+
+  # def value: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16511
+  sig { returns(T.nilable(String)) }
+  def value; end
+
+  # attr_reader value_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16432
+  sig { returns(T.nilable(Prism::Location)) }
+  def value_loc; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16426
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16556
+    def type; end
+  end
+end
+
+# This represents a token from the Ruby source.
+#
+# source://prism-0.20.0/lib/prism/parse_result.rb:424
+class Prism::Token
+  # Create a new token object with the given type, value, and location.
+  #
+  # @return [Token] a new instance of Token
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:435
+  def initialize(type, value, location); end
+
+  # Returns true if the given other token is equal to this token.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:462
+  def ==(other); end
+
+  # Implement the hash pattern matching interface for Token.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:442
+  def deconstruct_keys(keys); end
+
+  # A Location object representing the location of this token in the source.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:432
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Implement the pretty print interface for Token.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:447
+  def pretty_print(q); end
+
+  # The type of token that this token is.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:426
+  sig { returns(T.untyped) }
+  def type; end
+
+  # A byteslice of the source that this token represents.
+  #
+  # source://prism-0.20.0/lib/prism/parse_result.rb:429
+  sig { returns(String) }
+  def value; end
+end
+
+# This module is responsible for converting the prism syntax tree into other
+# syntax trees. At the moment it only supports converting to the
+# whitequark/parser gem's syntax tree, but support is planned for the
+# seattlerb/ruby_parser gem's syntax tree as well.
+#
+# source://prism-0.20.0/lib/prism/translation.rb:8
+module Prism::Translation; end
+
+# This class is the entry-point for converting a prism syntax tree into the
+# whitequark/parser gem's syntax tree. It inherits from the base parser for
+# the parser gem, and overrides the parse* methods to parse with prism and
+# then translate.
+#
+# source://prism-0.20.0/lib/prism/translation/parser.rb:14
+class Prism::Translation::Parser < ::Parser::Base
+  # The default encoding for Ruby files is UTF-8.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:33
+  def default_encoding; end
+
+  # Parses a source buffer and returns the AST.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:41
+  def parse(source_buffer); end
+
+  # Parses a source buffer and returns the AST and the source code comments.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:53
+  def parse_with_comments(source_buffer); end
+
+  # Parses a source buffer and returns the AST, the source code comments,
+  # and the tokens emitted by the lexer.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:70
+  def tokenize(source_buffer, _recover = T.unsafe(nil)); end
+
+  # Since prism resolves num params for us, we don't need to support this
+  # kind of logic here.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:90
+  def try_declare_numparam(node); end
+
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:28
+  def version; end
+
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:37
+  def yyerror; end
+
+  private
+
+  # Build the parser gem AST from the prism AST.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:131
+  def build_ast(program, offset_cache); end
+
+  # Build the parser gem comments from the prism comments.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:136
+  def build_comments(comments, offset_cache); end
+
+  # Prism deals with offsets in bytes, while the parser gem deals with
+  # offsets in characters. We need to handle this conversion in order to
+  # build the parser gem AST.
+  #
+  # If the bytesize of the source is the same as the length, then we can
+  # just use the offset directly. Otherwise, we build a hash that functions
+  # as a cache for the conversion.
+  #
+  # This is a good opportunity for some optimizations. If the source file
+  # has any multi-byte characters, this can tank the performance of the
+  # translator. We could make this significantly faster by using a
+  # different data structure for the cache.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:120
+  def build_offset_cache(source); end
+
+  # Build a range from a prism location.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:148
+  def build_range(location, offset_cache); end
+
+  # Build the parser gem tokens from the prism tokens.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:143
+  def build_tokens(tokens, offset_cache); end
+
+  # If there was a error generated during the parse, then raise an
+  # appropriate syntax error. Otherwise return the result.
+  #
+  # @raise [::Parser::SyntaxError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:98
+  def unwrap(result); end
+end
+
+# A visitor that knows how to convert a prism syntax tree into the
+# whitequark/parser gem's syntax tree.
+#
+# source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:9
+class Prism::Translation::Parser::Compiler < ::Prism::Compiler
+  # Initialize a new compiler with the given parser, offset cache, and
+  # options.
+  #
+  # @return [Compiler] a new instance of Compiler
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:39
+  def initialize(parser, offset_cache, forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # The Parser::Builders::Default instance that is being used to build the
+  # AST.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:18
+  def builder; end
+
+  # The types of values that can be forwarded in the current scope.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:29
+  def forwarding; end
+
+  # Whether or not the current node is in a destructure.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:32
+  def in_destructure; end
+
+  # Whether or not the current node is in a pattern.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:35
+  def in_pattern; end
+
+  # The offset cache that is used to map between byte and character
+  # offsets in the file.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:26
+  def offset_cache; end
+
+  # The Parser::Base instance that is being used to build the AST.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:14
+  def parser; end
+
+  # The Parser::Source::Buffer instance that is holding a reference to the
+  # source code.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:22
+  def source_buffer; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:58
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:52
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:64
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:70
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:101
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:76
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:82
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:107
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:137
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:147
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:153
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:191
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:197
+  def visit_block_local_variable_node(node); end
+
+  # A block on a keyword or method call.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:202
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:208
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:213
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:222
+  def visit_break_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:298
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:234
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:298
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:298
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:325
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:337
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:356
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:343
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:369
+  def visit_class_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:401
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:401
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:401
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:382
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:419
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # @@foo, @@bar = 1
+  # ^^^^^  ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:391
+  def visit_class_variable_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:440
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:440
+  def visit_constant_operator_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:440
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:494
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:464
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:494
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:494
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:512
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:484
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:425
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:458
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:434
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:521
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:570
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:582
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:588
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:598
+  def visit_embedded_variable_node(node); end
+
+  # begin; foo; ensure; bar; end
+  #             ^^^^^^^^^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:604
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:610
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:616
+  def visit_find_pattern_node(node); end
+
+  # 0..5
+  # ^^^^
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1294
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:630
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:636
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:654
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:660
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:669
+  def visit_forwarding_super_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:700
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:700
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:700
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:681
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:718
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # $foo, $bar = 1
+  # ^^^^  ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:690
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:724
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:734
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:752
+  def visit_if_node(node); end
+
+  # 1i
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:793
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:799
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:805
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:811
+  def visit_in_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:837
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:837
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:837
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:863
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:893
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:893
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:893
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:874
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:911
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  #
+  # @foo, @bar = 1
+  # ^^^^  ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:883
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:917
+  def visit_integer_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:923
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:923
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:938
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:953
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:963
+  def visit_interpolated_x_string_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:978
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:987
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:995
+  def visit_lambda_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1039
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1039
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1039
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1020
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1057
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  #
+  # foo, bar = 1
+  # ^^^  ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1029
+  def visit_local_variable_write_node(node); end
+
+  # /foo/
+  # ^^^^^
+  # if /foo/ then end
+  #    ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1328
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1067
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1077
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1087
+  def visit_match_write_node(node); end
+
+  # A node that is missing from the syntax tree. This is only used in the
+  # case of a syntax error. The parser gem doesn't have such a concept, so
+  # we invent our own here.
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1098
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1104
+  def visit_module_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1115
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1129
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1150
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1162
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1168
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1178
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1184
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1190
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1196
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1202
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1208
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1247
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1257
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1263
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1268
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1278
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1288
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1294
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1316
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1322
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1328
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1343
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1349
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1355
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  #
+  # @raise [CompilationError]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1373
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1382
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1388
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1397
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1409
+  def visit_self_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1415
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1427
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1433
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1439
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1451
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1464
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1470
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1487
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1510
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1528
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1534
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1543
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1573
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1595
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1609
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1631
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1649
+  def visit_yield_node(node); end
+
+  private
+
+  # Initialize a new compiler with the given option overrides, used to
+  # visit a subtree with the given options.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1663
+  def copy_compiler(forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # When *, **, &, or ... are used as an argument in a method call, we
+  # check if they were allowed by the current context. To determine that
+  # we build this lookup table.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1670
+  def find_forwarding(node); end
+
+  # Blocks can have a special set of parameters that automatically expand
+  # when given arrays if they have a single required parameter and no
+  # other parameters.
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1685
+  def procarg0?(parameters); end
+
+  # Constructs a new source range from the given start and end offsets.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1702
+  def srange(location); end
+
+  # Constructs a new source range by finding the given tokens between the
+  # given start offset and end offset. If the needle is not found, it
+  # returns nil.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1714
+  def srange_find(start_offset, end_offset, tokens); end
+
+  # Constructs a new source range from the given start and end offsets.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1707
+  def srange_offsets(start_offset, end_offset); end
+
+  # Transform a location into a token that the parser gem expects.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1723
+  def token(location); end
+
+  # Visit a block node on a call.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1728
+  def visit_block(call, block); end
+
+  # Visit a heredoc that can be either a string or an xstring.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1761
+  def visit_heredoc(node); end
+
+  # Visit a numeric node and account for the optional sign.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1808
+  def visit_numeric(node, value); end
+
+  # Within the given block, track that we're within a pattern.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1820
+  def within_pattern; end
+end
+
+# Raised when the tree is malformed or there is a bug in the compiler.
+#
+# source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:10
+class Prism::Translation::Parser::Compiler::CompilationError < ::StandardError; end
+
+# Locations in the parser gem AST are generated using this class. We
+# store a reference to its constant to make it slightly faster to look
+# up.
+#
+# source://prism-0.20.0/lib/prism/translation/parser/compiler.rb:1699
+Prism::Translation::Parser::Compiler::Range = Parser::Source::Range
+
+# The parser gem has a list of diagnostics with a hard-coded set of error
+# messages. We create our own diagnostic class in order to set our own
+# error messages.
+#
+# source://prism-0.20.0/lib/prism/translation/parser.rb:16
+class Prism::Translation::Parser::Diagnostic < ::Parser::Diagnostic
+  # Initialize a new diagnostic with the given message and location.
+  #
+  # @return [Diagnostic] a new instance of Diagnostic
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:20
+  def initialize(message, location); end
+
+  # The message generated by prism.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser.rb:17
+  def message; end
+end
+
+# Accepts a list of prism tokens and converts them into the expected
+# format for the parser gem.
+#
+# source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:8
+class Prism::Translation::Parser::Lexer
+  # Initialize the lexer with the given source buffer, prism tokens, and
+  # offset cache.
+  #
+  # @return [Lexer] a new instance of Lexer
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:193
+  def initialize(source_buffer, lexed, offset_cache); end
+
+  # An array of prism tokens that we lexed.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:186
+  def lexed; end
+
+  # A hash that maps offsets in bytes to offsets in characters.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:189
+  def offset_cache; end
+
+  # The Parser::Source::Buffer that the tokens were lexed from.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:183
+  def source_buffer; end
+
+  # Convert the prism tokens into the expected format for the parser gem.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:203
+  def to_a; end
+
+  private
+
+  # Parse a complex from the string representation.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:310
+  def parse_complex(value); end
+
+  # Parse a rational from the string representation.
+  #
+  # source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:323
+  def parse_rational(value); end
+end
+
+# source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:199
+Prism::Translation::Parser::Lexer::Range = Parser::Source::Range
+
+# The direct translating of types between the two lexers.
+#
+# source://prism-0.20.0/lib/prism/translation/parser/lexer.rb:10
+Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash)
+
+# Represents the use of the literal `true` keyword.
+#
+#     true
+#     ^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16566
+class Prism::TrueNode < ::Prism::Node
+  # def initialize: (Location location) -> void
+  #
+  # @return [TrueNode] a new instance of TrueNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16567
+  def initialize(location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16572
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16577
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16587
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16582
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> TrueNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16592
+  sig { params(params: T.untyped).returns(Prism::TrueNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16577
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16602
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16607
+  def inspect(inspector = T.unsafe(nil)); 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16626
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16636
+    def type; end
+  end
+end
+
+# Represents the use of the `undef` keyword.
+#
+#     undef :foo, :bar, :baz
+#     ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16646
+class Prism::UndefNode < ::Prism::Node
+  # def initialize: (Array[Node] names, Location keyword_loc, Location location) -> void
+  #
+  # @return [UndefNode] a new instance of UndefNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16653
+  def initialize(names, keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16660
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16665
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16675
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16670
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> UndefNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16680
+  sig { params(params: T.untyped).returns(Prism::UndefNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16665
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { names: Array[Node], keyword_loc: Location, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16692
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16702
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16697
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16650
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader names: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16647
+  sig { returns(T::Array[Prism::Node]) }
+  def names; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16723
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16733
+    def type; end
+  end
+end
+
+# Represents the use of the `unless` keyword, either in the block form or the modifier form.
+#
+#     bar unless foo
+#     ^^^^^^^^^^^^^^
+#
+#     unless foo then bar end
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16746
+class Prism::UnlessNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, Node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? consequent, Location? end_keyword_loc, Location location) -> void
+  #
+  # @return [UnlessNode] a new instance of UnlessNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16765
+  def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16776
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16785
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16799
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16790
+  def compact_child_nodes; end
+
+  # attr_reader consequent: ElseNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16759
+  sig { returns(T.nilable(Prism::ElseNode)) }
+  def consequent; end
+
+  # def copy: (**params) -> UnlessNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16804
+  sig { params(params: T.untyped).returns(Prism::UnlessNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16785
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16820
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16835
+  sig { returns(T.nilable(String)) }
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16762
+  sig { returns(T.nilable(Prism::Location)) }
+  def end_keyword_loc; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16840
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16825
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16747
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader predicate: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16750
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:16780
+  def set_newline_flag(newline_marked); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16756
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # def then_keyword: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16830
+  sig { returns(T.nilable(String)) }
+  def then_keyword; end
+
+  # attr_reader then_keyword_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16753
+  sig { returns(T.nilable(Prism::Location)) }
+  def then_keyword_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16876
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:16886
+    def type; end
+  end
+end
+
+# Represents the use of the `until` keyword, either in the block form or the modifier form.
+#
+#     bar until foo
+#     ^^^^^^^^^^^^^
+#
+#     until foo do bar end
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:16899
+class Prism::UntilNode < ::Prism::Node
+  # def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Node predicate, StatementsNode? statements, Location location) -> void
+  #
+  # @return [UntilNode] a new instance of UntilNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16915
+  def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16925
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16972
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16934
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16982
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16906
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16947
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16939
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> UntilNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16952
+  sig { params(params: T.untyped).returns(Prism::UntilNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16934
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16967
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16987
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16977
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16903
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader predicate: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16909
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:16929
+  def set_newline_flag(newline_marked); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16912
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17018
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:16900
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:17028
+    def type; end
+  end
+end
+
+# The version constant is set by reading the result of calling pm_version.
+Prism::VERSION = T.let(T.unsafe(nil), String)
+
+# A visitor is a class that provides a default implementation for every accept
+# method defined on the nodes. This means it can walk a tree without the
+# caller needing to define any special handling. This allows you to handle a
+# subset of the tree, while still walking the whole tree.
+#
+# For example, to find all of the method calls that call the `foo` method, you
+# could write:
+#
+#     class FooCalls < Prism::Visitor
+#       def visit_call_node(node)
+#         if node.name == "foo"
+#           # Do something with the node
+#         end
+#
+#         # Call super so that the visitor continues walking the tree
+#         super
+#       end
+#     end
+#
+# source://prism-0.20.0/lib/prism/visitor.rb:51
+class Prism::Visitor < ::Prism::BasicVisitor
+  # Visit a AliasGlobalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_float_node(node); end
+
+  # Visit a ForNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a KeywordHashNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_next_node(node); end
+
+  # Visit a NilNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_self_node(node); end
+
+  # Visit a SingletonClassNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node
+  #
+  # source://prism-0.20.0/lib/prism/visitor.rb:26
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `when` keyword within a case statement.
+#
+#     case true
+#     when true
+#     ^^^^^^^^^
+#     end
+#
+# source://prism-0.20.0/lib/prism/node.rb:17040
+class Prism::WhenNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, Array[Node] conditions, StatementsNode? statements, Location location) -> void
+  #
+  # @return [WhenNode] a new instance of WhenNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17050
+  def initialize(keyword_loc, conditions, statements, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17058
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17076
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17068
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17044
+  sig { returns(T::Array[Prism::Node]) }
+  def conditions; end
+
+  # def copy: (**params) -> WhenNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17081
+  sig { params(params: T.untyped).returns(Prism::WhenNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17063
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17094
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17104
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17099
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17041
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17047
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17131
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:17141
+    def type; end
+  end
+end
+
+# Represents the use of the `while` keyword, either in the block form or the modifier form.
+#
+#     bar while foo
+#     ^^^^^^^^^^^^^
+#
+#     while foo do bar end
+#     ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:17154
+class Prism::WhileNode < ::Prism::Node
+  # def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Node predicate, StatementsNode? statements, Location location) -> void
+  #
+  # @return [WhileNode] a new instance of WhileNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17170
+  def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17180
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17227
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17189
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17237
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17161
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17202
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17194
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> WhileNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17207
+  sig { params(params: T.untyped).returns(Prism::WhileNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17189
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17222
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17242
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17232
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17158
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # attr_reader predicate: Node
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17164
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # source://prism-0.20.0/lib/prism/node.rb:17184
+  def set_newline_flag(newline_marked); end
+
+  # attr_reader statements: StatementsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17167
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17273
+  def type; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17155
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:17283
+    def type; end
+  end
+end
+
+# Represents an xstring literal with no interpolation.
+#
+#     `foo`
+#     ^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:17293
+class Prism::XStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+  #
+  # @return [XStringNode] a new instance of XStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17309
+  def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17319
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17324
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17379
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17303
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17334
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17329
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17374
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17300
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (**params) -> XStringNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17339
+  sig { params(params: T.untyped).returns(Prism::XStringNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17324
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17354
+  def deconstruct_keys(keys); end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17364
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17359
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17384
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def opening: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17369
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17297
+  sig { returns(Prism::Location) }
+  def opening_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17409
+  def type; end
+
+  # attr_reader unescaped: String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17306
+  sig { returns(String) }
+  def unescaped; end
+
+  private
+
+  # Returns the value of attribute flags.
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17294
+  sig { returns(Integer) }
+  def flags; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:17419
+    def type; end
+  end
+end
+
+# Represents the use of the `yield` keyword.
+#
+#     yield 1
+#     ^^^^^^^
+#
+# source://prism-0.20.0/lib/prism/node.rb:17429
+class Prism::YieldNode < ::Prism::Node
+  # def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Location location) -> void
+  #
+  # @return [YieldNode] a new instance of YieldNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17442
+  def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end
+
+  # def accept: (Visitor visitor) -> void
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17451
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17436
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17468
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17461
+  def compact_child_nodes; end
+
+  # def copy: (**params) -> YieldNode
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17473
+  sig { params(params: T.untyped).returns(Prism::YieldNode) }
+  def copy(**params); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17456
+  sig { returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location }
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17487
+  def deconstruct_keys(keys); end
+
+  # def inspect(NodeInspector inspector) -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17507
+  def inspect(inspector = T.unsafe(nil)); end
+
+  # def keyword: () -> String
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17492
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17430
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17497
+  sig { returns(T.nilable(String)) }
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17433
+  sig { returns(T.nilable(Prism::Location)) }
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17502
+  sig { returns(T.nilable(String)) }
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17439
+  sig { returns(T.nilable(Prism::Location)) }
+  def rparen_loc; 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: () -> Symbol
+  #
+  # source://prism-0.20.0/lib/prism/node.rb:17535
+  def type; end
+
+  class << self
+    # 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: () -> Symbol
+    #
+    # source://prism-0.20.0/lib/prism/node.rb:17545
+    def type; end
+  end
+end
+
+# source://rubocop-1.34.1/lib/rubocop/target_ruby.rb:7
+RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array)