diff --git a/History.md b/History.md
index 7a88065..f1c209b 100644
--- a/History.md
+++ b/History.md
@@ -1,5 +1,9 @@
 # Boba History
 
+## 0.0.8
+
+- `ActiveRecordAssocationsPersisted` generate non-nilable types when there's an unconditional validation on the association, an unconditional validation on the foreign key for the association, or when there's a non-`null` db constraint on the foreign key.
+
 ## 0.0.7
 
 - Fix bug in `ActiveRecordColumnsPersisted` where `@column_type_option` can be `nil`.
diff --git a/lib/boba/active_record/attribute_service.rb b/lib/boba/active_record/attribute_service.rb
new file mode 100644
index 0000000..fcb4a0b
--- /dev/null
+++ b/lib/boba/active_record/attribute_service.rb
@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Boba
+  module ActiveRecord
+    module AttributeService
+      class << self
+        extend T::Sig
+
+        sig { params(constant: T.class_of(::ActiveRecord::Base), attribute: String).returns(T::Boolean) }
+        def has_unconditional_presence_validator?(constant, attribute)
+          return false unless constant.respond_to?(:validators_on)
+
+          constant.validators_on(attribute).any? do |validator|
+            next false unless validator.is_a?(::ActiveRecord::Validations::PresenceValidator)
+
+            !validator.options.key?(:if) && !validator.options.key?(:unless) && !validator.options.key?(:on)
+          end
+        end
+
+        sig { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
+        def has_non_null_database_constraint?(constant, column_name)
+          column = constant.columns_hash[column_name]
+          return false if column.nil?
+
+          !column.null
+        rescue StandardError
+          false
+        end
+
+        sig { params(constant: T.class_of(::ActiveRecord::Base), column_name: String).returns(T::Boolean) }
+        def virtual_attribute?(constant, column_name)
+          constant.columns_hash[column_name].nil?
+        end
+      end
+    end
+  end
+end
diff --git a/lib/boba/active_record/reflection_service.rb b/lib/boba/active_record/reflection_service.rb
new file mode 100644
index 0000000..9d17588
--- /dev/null
+++ b/lib/boba/active_record/reflection_service.rb
@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative("attribute_service")
+
+module Boba
+  module ActiveRecord
+    module ReflectionService
+      class << self
+        extend T::Sig
+
+        ReflectionType = T.type_alias do
+          T.any(::ActiveRecord::Reflection::ThroughReflection, ::ActiveRecord::Reflection::AssociationReflection)
+        end
+
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def has_one_and_required_reflection?(reflection)
+          return false unless reflection.has_one?
+          return true if !!reflection.options[:required]
+          return true if reflection_required_by_database_constraint?(reflection)
+
+          reflection_required_by_validation?(reflection)
+        end
+
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def belongs_to_and_non_optional_reflection?(reflection)
+          return false unless reflection.belongs_to?
+
+          optional = if reflection.options.key?(:required)
+            !reflection.options[:required]
+          else
+            reflection.options[:optional]
+          end
+          return !optional unless optional.nil?
+          return true if reflection_required_by_database_constraint?(reflection)
+          return true if reflection_required_by_validation?(reflection)
+
+          # nothing defined, so fall back to the default active record config
+          !!reflection.active_record.belongs_to_required_by_default
+        end
+
+        private
+
+        # check for non-nullable database constraint on the foreign key
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def reflection_required_by_database_constraint?(reflection)
+          Boba::ActiveRecord::AttributeService.has_non_null_database_constraint?(
+            reflection.active_record,
+            reflection.foreign_key,
+          )
+        end
+
+        # check for presence validator on the foreign key or on the association
+        sig { params(reflection: ReflectionType).returns(T::Boolean) }
+        def reflection_required_by_validation?(reflection)
+          return true if Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+            reflection.active_record,
+            reflection.foreign_key,
+          )
+
+          Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+            reflection.active_record,
+            reflection.name,
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/boba/version.rb b/lib/boba/version.rb
index b29f56d..91aaf8a 100644
--- a/lib/boba/version.rb
+++ b/lib/boba/version.rb
@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Boba
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end
diff --git a/lib/tapioca/dsl/compilers/active_record_associations_persisted.rb b/lib/tapioca/dsl/compilers/active_record_associations_persisted.rb
index 239a52e..138f80d 100644
--- a/lib/tapioca/dsl/compilers/active_record_associations_persisted.rb
+++ b/lib/tapioca/dsl/compilers/active_record_associations_persisted.rb
@@ -5,6 +5,8 @@
 
 return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordAssociations)
 
+require "boba/active_record/reflection_service"
+
 module Tapioca
   module Dsl
     module Compilers
@@ -188,39 +190,14 @@ def single_association_type_for(reflection)
           association_class = type_for(reflection)
           return as_nilable_type(association_class) unless association_type_option.persisted?
 
-          if has_one_and_required_reflection?(reflection) || belongs_to_and_non_optional_reflection?(reflection)
+          if Boba::ActiveRecord::ReflectionService.has_one_and_required_reflection?(reflection)
+            association_class
+          elsif Boba::ActiveRecord::ReflectionService.belongs_to_and_non_optional_reflection?(reflection)
             association_class
           else
             as_nilable_type(association_class)
           end
         end
-
-        # Note - one can do more here. If the association's attribute has an unconditional presence validation, it
-        # should also be considered required.
-        sig { params(reflection: ReflectionType).returns(T::Boolean) }
-        def has_one_and_required_reflection?(reflection)
-          reflection.has_one? && !!reflection.options[:required]
-        end
-
-        # Note - one can do more here. If the FK defining the belongs_to association is non-nullable at the DB level, or
-        # if the association's attribute has an unconditional presence validation, it should also be considered
-        # non-optional.
-        sig { params(reflection: ReflectionType).returns(T::Boolean) }
-        def belongs_to_and_non_optional_reflection?(reflection)
-          return false unless reflection.belongs_to?
-
-          optional = if reflection.options.key?(:required)
-            !reflection.options[:required]
-          else
-            reflection.options[:optional]
-          end
-
-          if optional.nil?
-            !!reflection.active_record.belongs_to_required_by_default
-          else
-            !optional
-          end
-        end
       end
     end
   end
diff --git a/lib/tapioca/dsl/compilers/active_record_columns_persisted.rb b/lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
index e34f699..051233a 100644
--- a/lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
+++ b/lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
@@ -5,6 +5,7 @@
 
 return unless defined?(Tapioca::Dsl::Compilers::ActiveRecordColumns)
 
+require "boba/active_record/attribute_service"
 require "tapioca/dsl/helpers/active_record_column_type_helper"
 
 module Tapioca
@@ -152,8 +153,14 @@ def type_for(attribute_name, column_name = attribute_name)
         def column_type_for(column_name)
           return ["T.untyped", "T.untyped"] if column_type_option.untyped?
 
-          nilable_column = !has_non_null_database_constraint?(column_name) &&
-            !has_unconditional_presence_validator?(column_name)
+          nilable_column = !Boba::ActiveRecord::AttributeService.has_non_null_database_constraint?(
+            @constant,
+            column_name,
+          )
+          nilable_column &&= !Boba::ActiveRecord::AttributeService.has_unconditional_presence_validator?(
+            @constant,
+            column_name,
+          )
 
           column_type = @constant.attribute_types[column_name]
           getter_type = column_type_helper.send(
@@ -169,7 +176,8 @@ def column_type_for(column_name)
               getter_type
             end
 
-          if column_type_option.persisted? && (virtual_attribute?(column_name) || !nilable_column)
+          virtual_attribute = Boba::ActiveRecord::AttributeService.virtual_attribute?(@constant, column_name)
+          if column_type_option.persisted? && (virtual_attribute || !nilable_column)
             [getter_type, setter_type]
           else
             getter_type = as_nilable_type(getter_type) unless column_type_helper.send(
@@ -180,30 +188,6 @@ def column_type_for(column_name)
           end
         end
 
-        sig { params(column_name: String).returns(T::Boolean) }
-        def virtual_attribute?(column_name)
-          @constant.columns_hash[column_name].nil?
-        end
-
-        sig { params(column_name: String).returns(T::Boolean) }
-        def has_non_null_database_constraint?(column_name)
-          column = @constant.columns_hash[column_name]
-          return false if column.nil?
-
-          !column.null
-        end
-
-        sig { params(column_name: String).returns(T::Boolean) }
-        def has_unconditional_presence_validator?(column_name)
-          return false unless @constant.respond_to?(:validators_on)
-
-          @constant.validators_on(column_name).any? do |validator|
-            next false unless validator.is_a?(ActiveRecord::Validations::PresenceValidator)
-
-            !validator.options.key?(:if) && !validator.options.key?(:unless) && !validator.options.key?(:on)
-          end
-        end
-
         sig do
           params(
             klass: RBI::Scope,
diff --git a/sorbet/rbi/dsl/.gitattributes b/sorbet/rbi/dsl/.gitattributes
new file mode 100644
index 0000000..d9bb82a
--- /dev/null
+++ b/sorbet/rbi/dsl/.gitattributes
@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true
diff --git a/sorbet/rbi/dsl/active_support/callbacks.rbi b/sorbet/rbi/dsl/active_support/callbacks.rbi
new file mode 100644
index 0000000..4c1ad13
--- /dev/null
+++ b/sorbet/rbi/dsl/active_support/callbacks.rbi
@@ -0,0 +1,23 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for dynamic methods in `ActiveSupport::Callbacks`.
+# Please instead update this file by running `bin/tapioca dsl ActiveSupport::Callbacks`.
+
+
+module ActiveSupport::Callbacks
+  include GeneratedInstanceMethods
+
+  mixes_in_class_methods GeneratedClassMethods
+
+  module GeneratedClassMethods
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+  end
+
+  module GeneratedInstanceMethods
+    def __callbacks; end
+    def __callbacks?; end
+  end
+end
diff --git a/sorbet/rbi/gems/prism@0.30.0.rbi b/sorbet/rbi/gems/prism@0.30.0.rbi
deleted file mode 100644
index 9aec9c3..0000000
--- a/sorbet/rbi/gems/prism@0.30.0.rbi
+++ /dev/null
@@ -1,39212 +0,0 @@
-# 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`.
-
-
-# typed: strict
-
-# =begin
-# This file is generated by the templates/template.rb script and should not be
-# modified manually. See templates/rbi/prism/node.rbi.erb
-# if you are looking to modify the template
-# =end
-# =begin
-# This file is generated by the templates/template.rb script and should not be
-# modified manually. See templates/rbi/prism/visitor.rbi.erb
-# if you are looking to modify the template
-# =end
-
-# We keep these shims in here because our client libraries might not have parser
-# in their bundle.
-module Parser; end
-
-class Parser::Base; end
-
-# The Prism Ruby parser.
-#
-# "Parsing Ruby is suddenly manageable!"
-#   - You, hopefully
-#
-# source://prism//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) -> LexCompat::Result
-    #
-    # 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//lib/prism.rb#45
-    sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
-    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//lib/prism.rb#55
-    sig { params(source: String).returns(T::Array[T.untyped]) }
-    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//lib/prism.rb#63
-    sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
-    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
-
-    # Mirror the Prism.parse_failure? API by using the serialization API.
-    #
-    # @return [Boolean]
-    def parse_failure?(*_arg0); 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
-
-    # Mirror the Prism.parse_file_failure? API by using the serialization API.
-    #
-    # @return [Boolean]
-    def parse_file_failure?(*_arg0); 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_stream API by using the serialization API.
-    def parse_stream(*_arg0); end
-
-    # Mirror the Prism.parse_success? API by using the serialization API.
-    #
-    # @return [Boolean]
-    def parse_success?(*_arg0); end
-
-    # Mirror the Prism.profile API by using the serialization API.
-    def profile(*_arg0); end
-
-    # Mirror the Prism.profile_file API by using the serialization API.
-    def profile_file(*_arg0); end
-  end
-end
-
-# Specialized version of Prism::Source for source code that includes ASCII
-# characters only. This class is used to apply performance optimizations that
-# cannot be applied to sources that include multibyte characters. Sources that
-# include multibyte characters are represented by the Prism::Source class.
-#
-# source://prism//lib/prism/parse_result.rb#126
-class Prism::ASCIISource < ::Prism::Source
-  # Return the column number in characters for the given byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#133
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_column(byte_offset); end
-
-  # Return the character offset for the given byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#128
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_offset(byte_offset); end
-
-  # Specialized version of `code_units_column` that does not depend on
-  # `code_units_offset`, which is a more expensive operation. This is
-  # essentialy the same as `Prism::Source#column`.
-  #
-  # source://prism//lib/prism/parse_result.rb#150
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_column(byte_offset, encoding); end
-
-  # Returns the offset from the start of the file for the given byte offset
-  # counting in code units for the given encoding.
-  #
-  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
-  # concept of code units that differs from the number of characters in other
-  # encodings, it is not captured here.
-  #
-  # source://prism//lib/prism/parse_result.rb#143
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_offset(byte_offset, encoding); end
-end
-
-# Represents the use of the `alias` keyword to alias a global variable.
-#
-#     alias $foo $bar
-#     ^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#176
-class Prism::AliasGlobalVariableNode < ::Prism::Node
-  # def initialize: (Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
-  #
-  # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
-  #
-  # source://prism//lib/prism/node.rb#178
-  sig do
-    params(
-      source: Prism::Source,
-      new_name: Prism::Node,
-      old_name: Prism::Node,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, new_name, old_name, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#281
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#187
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#192
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#202
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#197
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasGlobalVariableNode
-  #
-  # source://prism//lib/prism/node.rb#207
-  sig do
-    params(
-      new_name: Prism::Node,
-      old_name: Prism::Node,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::AliasGlobalVariableNode)
-  end
-  def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#192
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#215
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#247
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#242
-  sig { returns(String) }
-  def keyword; end
-
-  # The location of the `alias` keyword.
-  #
-  #     alias $foo $bar
-  #     ^^^^^
-  #
-  # source://prism//lib/prism/node.rb#235
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # Represents the new name of the global variable that can be used after aliasing. This can be either a global variable, a back reference, or a numbered reference.
-  #
-  #     alias $foo $bar
-  #           ^^^^
-  #
-  # source://prism//lib/prism/node.rb#223
-  sig { returns(Prism::Node) }
-  def new_name; end
-
-  # Represents the old name of the global variable that could be used before aliasing. This can be either a global variable, a back reference, or a numbered reference.
-  #
-  #     alias $foo $bar
-  #                ^^^^
-  #
-  # source://prism//lib/prism/node.rb#229
-  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//lib/prism/node.rb#265
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#275
-    def type; end
-  end
-end
-
-# Represents the use of the `alias` keyword to alias a method.
-#
-#     alias foo bar
-#     ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#293
-class Prism::AliasMethodNode < ::Prism::Node
-  # def initialize: (Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
-  #
-  # @return [AliasMethodNode] a new instance of AliasMethodNode
-  #
-  # source://prism//lib/prism/node.rb#295
-  sig do
-    params(
-      source: Prism::Source,
-      new_name: Prism::Node,
-      old_name: Prism::Node,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, new_name, old_name, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#389
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#304
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#309
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#319
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#314
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasMethodNode
-  #
-  # source://prism//lib/prism/node.rb#324
-  sig do
-    params(
-      new_name: Prism::Node,
-      old_name: Prism::Node,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::AliasMethodNode)
-  end
-  def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#309
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#332
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#355
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#350
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#343
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # attr_reader new_name: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#337
-  sig { returns(Prism::Node) }
-  def new_name; end
-
-  # attr_reader old_name: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#340
-  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//lib/prism/node.rb#373
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#383
-    def type; end
-  end
-end
-
-# Represents an alternation pattern in pattern matching.
-#
-#     foo => bar | baz
-#            ^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#401
-class Prism::AlternationPatternNode < ::Prism::Node
-  # def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
-  #
-  # @return [AlternationPatternNode] a new instance of AlternationPatternNode
-  #
-  # source://prism//lib/prism/node.rb#403
-  sig do
-    params(
-      source: Prism::Source,
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, left, right, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#497
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#412
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#417
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#427
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#422
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AlternationPatternNode
-  #
-  # source://prism//lib/prism/node.rb#432
-  sig do
-    params(
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::AlternationPatternNode)
-  end
-  def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#417
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#440
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#463
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader left: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#445
-  sig { returns(Prism::Node) }
-  def left; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#458
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#451
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader right: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#448
-  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//lib/prism/node.rb#481
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#491
-    def type; end
-  end
-end
-
-# Represents the use of the `&&` operator or the `and` keyword.
-#
-#     left and right
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#509
-class Prism::AndNode < ::Prism::Node
-  # def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
-  #
-  # @return [AndNode] a new instance of AndNode
-  #
-  # source://prism//lib/prism/node.rb#511
-  sig do
-    params(
-      source: Prism::Source,
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, left, right, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#620
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#520
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#525
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#535
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#530
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AndNode
-  #
-  # source://prism//lib/prism/node.rb#540
-  sig do
-    params(
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::AndNode)
-  end
-  def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#525
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#548
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#586
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#559
-  sig { returns(Prism::Node) }
-  def left; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#581
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `and` keyword or the `&&` operator.
-  #
-  #     left and right
-  #          ^^^
-  #
-  # source://prism//lib/prism/node.rb#574
-  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//lib/prism/node.rb#568
-  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//lib/prism/node.rb#604
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#614
-    def type; end
-  end
-end
-
-# Represents a set of arguments to a method or a keyword.
-#
-#     return foo, bar, baz
-#            ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#632
-class Prism::ArgumentsNode < ::Prism::Node
-  # def initialize: (Integer flags, Array[Prism::node] arguments, Location location) -> void
-  #
-  # @return [ArgumentsNode] a new instance of ArgumentsNode
-  #
-  # source://prism//lib/prism/node.rb#634
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      arguments: T::Array[Prism::Node],
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, arguments, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#726
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#642
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#679
-  sig { returns(T::Array[Prism::Node]) }
-  def arguments; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#647
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#657
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#652
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def contains_keyword_splat?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#687
-  sig { returns(T::Boolean) }
-  def contains_keyword_splat?; end
-
-  # def contains_keywords?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#682
-  sig { returns(T::Boolean) }
-  def contains_keywords?; end
-
-  # def copy: (?flags: Integer, ?arguments: Array[Prism::node], ?location: Location) -> ArgumentsNode
-  #
-  # source://prism//lib/prism/node.rb#662
-  sig do
-    params(
-      flags: Integer,
-      arguments: T::Array[Prism::Node],
-      location: Prism::Location
-    ).returns(Prism::ArgumentsNode)
-  end
-  def copy(flags: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#647
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, arguments: Array[Prism::node], location: Location }
-  #
-  # source://prism//lib/prism/node.rb#670
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#692
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#710
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#675
-  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//lib/prism/node.rb#720
-    def type; end
-  end
-end
-
-# Flags for arguments nodes.
-#
-# source://prism//lib/prism/node.rb#19127
-module Prism::ArgumentsNodeFlags; end
-
-# if arguments contain keywords
-#
-# source://prism//lib/prism/node.rb#19129
-Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer)
-
-# if arguments contain keyword splat
-#
-# source://prism//lib/prism/node.rb#19132
-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//lib/prism/node.rb#738
-class Prism::ArrayNode < ::Prism::Node
-  # def initialize: (Integer flags, Array[Prism::node] elements, Location? opening_loc, Location? closing_loc, Location location) -> void
-  #
-  # @return [ArrayNode] a new instance of ArrayNode
-  #
-  # source://prism//lib/prism/node.rb#740
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      elements: T::Array[Prism::Node],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, elements, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#875
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#750
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#755
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#836
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # Represents the optional source location for the closing token.
-  #
-  #     [1,2,3]                 # "]"
-  #     %w[foo bar baz]         # "]"
-  #     %I(apple orange banana) # ")"
-  #     foo = 1, 2, 3           # nil
-  #
-  # source://prism//lib/prism/node.rb#813
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#765
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#760
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def contains_splat?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#826
-  sig { returns(T::Boolean) }
-  def contains_splat?; end
-
-  # def copy: (?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayNode
-  #
-  # source://prism//lib/prism/node.rb#770
-  sig do
-    params(
-      flags: Integer,
-      elements: T::Array[Prism::Node],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::ArrayNode)
-  end
-  def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#755
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#778
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
-  #
-  # source://prism//lib/prism/node.rb#787
-  sig { returns(T::Array[Prism::Node]) }
-  def elements; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#841
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#831
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # Represents the optional source location for the opening token.
-  #
-  #     [1,2,3]                 # "["
-  #     %w[foo bar baz]         # "%w["
-  #     %I(apple orange banana) # "%I("
-  #     foo = 1, 2, 3           # nil
-  #
-  # source://prism//lib/prism/node.rb#795
-  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//lib/prism/node.rb#859
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#783
-  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//lib/prism/node.rb#869
-    def type; end
-  end
-end
-
-# Flags for array nodes.
-#
-# source://prism//lib/prism/node.rb#19136
-module Prism::ArrayNodeFlags; end
-
-# if array contains splat nodes
-#
-# source://prism//lib/prism/node.rb#19138
-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//lib/prism/node.rb#901
-class Prism::ArrayPatternNode < ::Prism::Node
-  # def initialize: (Prism::node? constant, Array[Prism::node] requireds, Prism::node? rest, Array[Prism::node] posts, Location? opening_loc, Location? closing_loc, Location location) -> void
-  #
-  # @return [ArrayPatternNode] a new instance of ArrayPatternNode
-  #
-  # source://prism//lib/prism/node.rb#903
-  sig do
-    params(
-      source: Prism::Source,
-      constant: T.nilable(Prism::Node),
-      requireds: T::Array[Prism::Node],
-      rest: T.nilable(Prism::Node),
-      posts: T::Array[Prism::Node],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, constant, requireds, rest, posts, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1035
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#915
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#920
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#996
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#978
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#935
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#925
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader constant: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#953
-  sig { returns(T.nilable(Prism::Node)) }
-  def constant; end
-
-  # def copy: (?constant: Prism::node?, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayPatternNode
-  #
-  # source://prism//lib/prism/node.rb#940
-  sig do
-    params(
-      constant: T.nilable(Prism::Node),
-      requireds: T::Array[Prism::Node],
-      rest: T.nilable(Prism::Node),
-      posts: T::Array[Prism::Node],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::ArrayPatternNode)
-  end
-  def copy(constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#920
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#948
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1001
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#991
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#965
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader posts: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#962
-  sig { returns(T::Array[Prism::Node]) }
-  def posts; end
-
-  # attr_reader requireds: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#956
-  sig { returns(T::Array[Prism::Node]) }
-  def requireds; end
-
-  # attr_reader rest: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#959
-  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//lib/prism/node.rb#1019
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1029
-    def type; end
-  end
-end
-
-# Represents a hash key/value pair.
-#
-#     { a => b }
-#       ^^^^^^
-#
-# source://prism//lib/prism/node.rb#1052
-class Prism::AssocNode < ::Prism::Node
-  # def initialize: (Prism::node key, Prism::node value, Location? operator_loc, Location location) -> void
-  #
-  # @return [AssocNode] a new instance of AssocNode
-  #
-  # source://prism//lib/prism/node.rb#1054
-  sig do
-    params(
-      source: Prism::Source,
-      key: Prism::Node,
-      value: Prism::Node,
-      operator_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, key, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1172
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1063
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1068
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1078
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1073
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?, ?location: Location) -> AssocNode
-  #
-  # source://prism//lib/prism/node.rb#1083
-  sig do
-    params(
-      key: Prism::Node,
-      value: Prism::Node,
-      operator_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::AssocNode)
-  end
-  def copy(key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1068
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { key: Prism::node, value: Prism::node, operator_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1091
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1138
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#1105
-  sig { returns(Prism::Node) }
-  def key; end
-
-  # def operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#1133
-  sig { returns(T.nilable(String)) }
-  def operator; end
-
-  # The location of the `=>` operator, if present.
-  #
-  #     { foo => bar }
-  #           ^^
-  #
-  # source://prism//lib/prism/node.rb#1120
-  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//lib/prism/node.rb#1156
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1114
-  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//lib/prism/node.rb#1166
-    def type; end
-  end
-end
-
-# Represents a splat in a hash literal.
-#
-#     { **foo }
-#       ^^^^^
-#
-# source://prism//lib/prism/node.rb#1184
-class Prism::AssocSplatNode < ::Prism::Node
-  # def initialize: (Prism::node? value, Location operator_loc, Location location) -> void
-  #
-  # @return [AssocSplatNode] a new instance of AssocSplatNode
-  #
-  # source://prism//lib/prism/node.rb#1186
-  sig do
-    params(
-      source: Prism::Source,
-      value: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1284
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1194
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1199
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1211
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1204
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Prism::node?, ?operator_loc: Location, ?location: Location) -> AssocSplatNode
-  #
-  # source://prism//lib/prism/node.rb#1216
-  sig do
-    params(
-      value: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::AssocSplatNode)
-  end
-  def copy(value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1199
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node?, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1224
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1250
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#1245
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `**` operator.
-  #
-  #     { **x }
-  #       ^^
-  #
-  # source://prism//lib/prism/node.rb#1238
-  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//lib/prism/node.rb#1268
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
-  #
-  #     { **foo }
-  #         ^^^
-  #
-  # source://prism//lib/prism/node.rb#1232
-  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//lib/prism/node.rb#1278
-    def type; end
-  end
-end
-
-# The FFI backend is used on other Ruby implementations.
-#
-# source://prism//lib/prism.rb#81
-Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
-
-# Represents reading a reference to a field in the previous match.
-#
-#     $'
-#     ^^
-#
-# source://prism//lib/prism/node.rb#1295
-class Prism::BackReferenceReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
-  #
-  # source://prism//lib/prism/node.rb#1297
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1378
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1304
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1309
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1319
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1314
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> BackReferenceReadNode
-  #
-  # source://prism//lib/prism/node.rb#1324
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::BackReferenceReadNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1309
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1332
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1344
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The name of the back-reference variable, including the leading `$`.
-  #
-  #     $& # name `:$&`
-  #
-  #     $+ # name `:$+`
-  #
-  # source://prism//lib/prism/node.rb#1341
-  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//lib/prism/node.rb#1362
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1372
-    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//lib/prism/visitor.rb#14
-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//lib/prism/visitor.rb#17
-  sig { params(node: T.nilable(Prism::Node)).void }
-  def visit(node); end
-
-  # Visits each node in `nodes` by calling `accept` on each one.
-  #
-  # source://prism//lib/prism/visitor.rb#23
-  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
-  def visit_all(nodes); end
-
-  # Visits the child nodes of `node` by calling `accept` on each one.
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::Node).void }
-  def visit_child_nodes(node); end
-end
-
-# Represents a begin statement.
-#
-#     begin
-#       foo
-#     end
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#1390
-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//lib/prism/node.rb#1392
-  sig do
-    params(
-      source: Prism::Source,
-      begin_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      rescue_clause: T.nilable(Prism::RescueNode),
-      else_clause: T.nilable(Prism::ElseNode),
-      ensure_clause: T.nilable(Prism::EnsureNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1524
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1404
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def begin_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#1480
-  sig { returns(T.nilable(String)) }
-  def begin_keyword; end
-
-  # attr_reader begin_keyword_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#1442
-  sig { returns(T.nilable(Prism::Location)) }
-  def begin_keyword_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1409
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1424
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1414
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?, ?location: Location) -> BeginNode
-  #
-  # source://prism//lib/prism/node.rb#1429
-  sig do
-    params(
-      begin_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      rescue_clause: T.nilable(Prism::RescueNode),
-      else_clause: T.nilable(Prism::ElseNode),
-      ensure_clause: T.nilable(Prism::EnsureNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::BeginNode)
-  end
-  def copy(begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1409
-  sig { override.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//lib/prism/node.rb#1437
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader else_clause: ElseNode?
-  #
-  # source://prism//lib/prism/node.rb#1461
-  sig { returns(T.nilable(Prism::ElseNode)) }
-  def else_clause; end
-
-  # def end_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#1485
-  sig { returns(T.nilable(String)) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#1467
-  sig { returns(T.nilable(Prism::Location)) }
-  def end_keyword_loc; end
-
-  # attr_reader ensure_clause: EnsureNode?
-  #
-  # source://prism//lib/prism/node.rb#1464
-  sig { returns(T.nilable(Prism::EnsureNode)) }
-  def ensure_clause; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1490
-  sig { override.returns(String) }
-  def inspect; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#79
-  def newline!(lines); end
-
-  # attr_reader rescue_clause: RescueNode?
-  #
-  # source://prism//lib/prism/node.rb#1458
-  sig { returns(T.nilable(Prism::RescueNode)) }
-  def rescue_clause; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#1455
-  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//lib/prism/node.rb#1508
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1518
-    def type; end
-  end
-end
-
-# Represents block method arguments.
-#
-#     bar(&args)
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#1539
-class Prism::BlockArgumentNode < ::Prism::Node
-  # def initialize: (Prism::node? expression, Location operator_loc, Location location) -> void
-  #
-  # @return [BlockArgumentNode] a new instance of BlockArgumentNode
-  #
-  # source://prism//lib/prism/node.rb#1541
-  sig do
-    params(
-      source: Prism::Source,
-      expression: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, expression, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1633
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1549
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1554
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1566
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1559
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?expression: Prism::node?, ?operator_loc: Location, ?location: Location) -> BlockArgumentNode
-  #
-  # source://prism//lib/prism/node.rb#1571
-  sig do
-    params(
-      expression: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::BlockArgumentNode)
-  end
-  def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1554
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node?, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1579
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader expression: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#1584
-  sig { returns(T.nilable(Prism::Node)) }
-  def expression; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1599
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#1594
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#1587
-  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//lib/prism/node.rb#1617
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1627
-    def type; end
-  end
-end
-
-# Represents a block local variable.
-#
-#     a { |; b| }
-#            ^
-#
-# source://prism//lib/prism/node.rb#1644
-class Prism::BlockLocalVariableNode < ::Prism::Node
-  # def initialize: (Integer flags, Symbol name, Location location) -> void
-  #
-  # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
-  #
-  # source://prism//lib/prism/node.rb#1646
-  sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void }
-  def initialize(source, flags, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1733
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1654
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1659
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1669
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1664
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> BlockLocalVariableNode
-  #
-  # source://prism//lib/prism/node.rb#1674
-  sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) }
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1659
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1682
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1699
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#1691
-  sig { returns(Symbol) }
-  def name; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#1694
-  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//lib/prism/node.rb#1717
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#1687
-  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//lib/prism/node.rb#1727
-    def type; end
-  end
-end
-
-# Represents a block of ruby code.
-#
-#     [1, 2, 3].each { |i| puts x }
-#                    ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#1744
-class Prism::BlockNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, Prism::node? parameters, Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
-  #
-  # @return [BlockNode] a new instance of BlockNode
-  #
-  # source://prism//lib/prism/node.rb#1746
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      parameters: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, parameters, body, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1860
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1757
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#1799
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1762
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#1821
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#1809
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1775
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1767
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?locals: Array[Symbol], ?parameters: Prism::node?, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> BlockNode
-  #
-  # source://prism//lib/prism/node.rb#1780
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      parameters: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::BlockNode)
-  end
-  def copy(locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1762
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], parameters: Prism::node?, body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#1788
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1826
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#1793
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#1816
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#1802
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader parameters: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#1796
-  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//lib/prism/node.rb#1844
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#1854
-    def type; end
-  end
-end
-
-# Represents a block parameter to a method, block, or lambda definition.
-#
-#     def a(&b)
-#           ^^
-#     end
-#
-# source://prism//lib/prism/node.rb#1876
-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//lib/prism/node.rb#1878
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#1992
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#1888
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1893
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#1903
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#1898
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> BlockParameterNode
-  #
-  # source://prism//lib/prism/node.rb#1908
-  sig do
-    params(
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::BlockParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#1893
-  sig { override.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//lib/prism/node.rb#1916
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#1958
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol?
-  #
-  # source://prism//lib/prism/node.rb#1925
-  sig { returns(T.nilable(Symbol)) }
-  def name; end
-
-  # attr_reader name_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#1928
-  sig { returns(T.nilable(Prism::Location)) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#1953
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#1941
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#1948
-  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//lib/prism/node.rb#1976
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#1921
-  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//lib/prism/node.rb#1986
-    def type; end
-  end
-end
-
-# Represents a block's parameters declaration.
-#
-#     -> (a, b = 1; local) { }
-#        ^^^^^^^^^^^^^^^^^
-#
-#     foo do |a, b = 1; local|
-#            ^^^^^^^^^^^^^^^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#2009
-class Prism::BlockParametersNode < ::Prism::Node
-  # def initialize: (ParametersNode? parameters, Array[BlockLocalVariableNode] locals, Location? opening_loc, Location? closing_loc, Location location) -> void
-  #
-  # @return [BlockParametersNode] a new instance of BlockParametersNode
-  #
-  # source://prism//lib/prism/node.rb#2011
-  sig do
-    params(
-      source: Prism::Source,
-      parameters: T.nilable(Prism::ParametersNode),
-      locals: T::Array[Prism::BlockLocalVariableNode],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, parameters, locals, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#2133
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2021
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2026
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2094
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2076
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2039
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2031
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> BlockParametersNode
-  #
-  # source://prism//lib/prism/node.rb#2044
-  sig do
-    params(
-      parameters: T.nilable(Prism::ParametersNode),
-      locals: T::Array[Prism::BlockLocalVariableNode],
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::BlockParametersNode)
-  end
-  def copy(parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2026
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#2052
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#2099
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[BlockLocalVariableNode]
-  #
-  # source://prism//lib/prism/node.rb#2060
-  sig { returns(T::Array[Prism::BlockLocalVariableNode]) }
-  def locals; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2089
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2063
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader parameters: ParametersNode?
-  #
-  # source://prism//lib/prism/node.rb#2057
-  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//lib/prism/node.rb#2117
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#2127
-    def type; end
-  end
-end
-
-# Represents the use of the `break` keyword.
-#
-#     break foo
-#     ^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#2147
-class Prism::BreakNode < ::Prism::Node
-  # def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
-  #
-  # @return [BreakNode] a new instance of BreakNode
-  #
-  # source://prism//lib/prism/node.rb#2149
-  sig do
-    params(
-      source: Prism::Source,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, arguments, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#2247
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2157
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     break foo
-  #           ^^^
-  #
-  # source://prism//lib/prism/node.rb#2195
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2162
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2174
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2167
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> BreakNode
-  #
-  # source://prism//lib/prism/node.rb#2179
-  sig do
-    params(
-      arguments: T.nilable(Prism::ArgumentsNode),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::BreakNode)
-  end
-  def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2162
-  sig { override.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//lib/prism/node.rb#2187
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#2213
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#2208
-  sig { returns(String) }
-  def keyword; end
-
-  # The location of the `break` keyword.
-  #
-  #     break foo
-  #     ^^^^^
-  #
-  # source://prism//lib/prism/node.rb#2201
-  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//lib/prism/node.rb#2231
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#2241
-    def type; end
-  end
-end
-
-# Represents the use of the `&&=` operator on a call.
-#
-#     foo.bar &&= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#2258
-class Prism::CallAndWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [CallAndWriteNode] a new instance of CallAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2260
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#2428
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2274
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2369
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2379
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2317
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2279
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2292
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2284
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2297
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::CallAndWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2279
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#2305
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2374
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#2394
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def message: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2384
-  sig { returns(T.nilable(String)) }
-  def message; end
-
-  # attr_reader message_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2330
-  sig { returns(T.nilable(Prism::Location)) }
-  def message_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#2389
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#2349
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader read_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2343
-  sig { returns(Symbol) }
-  def read_name; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#2314
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2359
-  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//lib/prism/node.rb#2412
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#2356
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2364
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  # attr_reader write_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2346
-  sig { returns(Symbol) }
-  def write_name; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#2310
-  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//lib/prism/node.rb#2422
-    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//lib/prism/node.rb#2460
-class Prism::CallNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Prism::node? block, Location location) -> void
-  #
-  # @return [CallNode] a new instance of CallNode
-  #
-  # source://prism//lib/prism/node.rb#2462
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      name: Symbol,
-      message_loc: T.nilable(Prism::Location),
-      opening_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: T.nilable(Prism::Location),
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#2665
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2477
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#2572
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2601
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#2588
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2611
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2530
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2482
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2626
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2575
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2496
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2487
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: Prism::node?, ?location: Location) -> CallNode
-  #
-  # source://prism//lib/prism/node.rb#2501
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      name: Symbol,
-      message_loc: T.nilable(Prism::Location),
-      opening_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: T.nilable(Prism::Location),
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).returns(Prism::CallNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2482
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Prism::node?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#2509
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # When a call node has the attribute_write flag set, it means that the call
-  # is using the attribute write syntax. This is either a method call to []=
-  # or a method call to a method that ends with =. Either way, the = sign is
-  # present in the source.
-  #
-  # Prism returns the message_loc _without_ the = sign attached, because there
-  # can be any amount of space between the message and the = sign. However,
-  # sometimes you want the location of the full message including the inner
-  # space and the = sign. This method provides that.
-  #
-  # source://prism//lib/prism/node_ext.rb#315
-  sig { returns(T.nilable(Prism::Location)) }
-  def full_message_loc; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2606
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#2631
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def message: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2616
-  sig { returns(T.nilable(String)) }
-  def message; end
-
-  # attr_reader message_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2546
-  sig { returns(T.nilable(Prism::Location)) }
-  def message_loc; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2543
-  sig { returns(Symbol) }
-  def name; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2621
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2559
-  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//lib/prism/node.rb#2527
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2591
-  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//lib/prism/node.rb#2649
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2596
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#2514
-  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//lib/prism/node.rb#2659
-    def type; end
-  end
-end
-
-# Flags for call nodes.
-#
-# source://prism//lib/prism/node.rb#19142
-module Prism::CallNodeFlags; end
-
-# a call that is an attribute write, so the value being written should be returned
-#
-# source://prism//lib/prism/node.rb#19150
-Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
-
-# a call that ignores method visibility
-#
-# source://prism//lib/prism/node.rb#19153
-Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer)
-
-# &. operator
-#
-# source://prism//lib/prism/node.rb#19144
-Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer)
-
-# a call that could have been a local variable
-#
-# source://prism//lib/prism/node.rb#19147
-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//lib/prism/node.rb#2683
-class Prism::CallOperatorWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2685
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      binary_operator: Symbol,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#2852
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2700
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2798
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2775
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#2778
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2808
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2743
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2705
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2718
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2710
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2723
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      binary_operator: Symbol,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::CallOperatorWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2705
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#2731
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2803
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#2818
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def message: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2813
-  sig { returns(T.nilable(String)) }
-  def message; end
-
-  # attr_reader message_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2756
-  sig { returns(T.nilable(Prism::Location)) }
-  def message_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#323
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#330
-  def operator_loc; end
-
-  # attr_reader read_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2769
-  sig { returns(Symbol) }
-  def read_name; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#2740
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2788
-  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//lib/prism/node.rb#2836
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#2785
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2793
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  # attr_reader write_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2772
-  sig { returns(Symbol) }
-  def write_name; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#2736
-  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//lib/prism/node.rb#2846
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator on a call.
-#
-#     foo.bar ||= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#2870
-class Prism::CallOrWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [CallOrWriteNode] a new instance of CallOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2872
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3040
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#2886
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2981
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2991
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2929
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2891
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#2904
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#2896
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#2909
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      message_loc: T.nilable(Prism::Location),
-      read_name: Symbol,
-      write_name: Symbol,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::CallOrWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#2891
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#2917
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2986
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3006
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def message: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#2996
-  sig { returns(T.nilable(String)) }
-  def message; end
-
-  # attr_reader message_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#2942
-  sig { returns(T.nilable(Prism::Location)) }
-  def message_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3001
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#2961
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader read_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2955
-  sig { returns(Symbol) }
-  def read_name; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#2926
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2971
-  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//lib/prism/node.rb#3024
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#2968
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#2976
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  # attr_reader write_name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#2958
-  sig { returns(Symbol) }
-  def write_name; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#2922
-  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//lib/prism/node.rb#3034
-    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//lib/prism/node.rb#3065
-class Prism::CallTargetNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node receiver, Location call_operator_loc, Symbol name, Location message_loc, Location location) -> void
-  #
-  # @return [CallTargetNode] a new instance of CallTargetNode
-  #
-  # source://prism//lib/prism/node.rb#3067
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: Prism::Node,
-      call_operator_loc: Prism::Location,
-      name: Symbol,
-      message_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, name, message_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3199
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3078
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#3145
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # def call_operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3155
-  sig { returns(String) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3118
-  sig { returns(Prism::Location) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3083
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3093
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3088
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location, ?location: Location) -> CallTargetNode
-  #
-  # source://prism//lib/prism/node.rb#3098
-  sig do
-    params(
-      flags: Integer,
-      receiver: Prism::Node,
-      call_operator_loc: Prism::Location,
-      name: Symbol,
-      message_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::CallTargetNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3083
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3106
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#3150
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3165
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def message: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3160
-  sig { returns(String) }
-  def message; end
-
-  # attr_reader message_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3128
-  sig { returns(Prism::Location) }
-  def message_loc; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#3125
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader receiver: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3115
-  sig { returns(Prism::Node) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#3135
-  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//lib/prism/node.rb#3183
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#3140
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#3111
-  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//lib/prism/node.rb#3193
-    def type; end
-  end
-end
-
-# Represents assigning to a local variable in pattern matching.
-#
-#     foo => [bar => baz]
-#            ^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3213
-class Prism::CapturePatternNode < ::Prism::Node
-  # def initialize: (Prism::node value, Prism::node target, Location operator_loc, Location location) -> void
-  #
-  # @return [CapturePatternNode] a new instance of CapturePatternNode
-  #
-  # source://prism//lib/prism/node.rb#3215
-  sig do
-    params(
-      source: Prism::Source,
-      value: Prism::Node,
-      target: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, value, target, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3309
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3224
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3229
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3239
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3234
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Prism::node, ?target: Prism::node, ?operator_loc: Location, ?location: Location) -> CapturePatternNode
-  #
-  # source://prism//lib/prism/node.rb#3244
-  sig do
-    params(
-      value: Prism::Node,
-      target: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::CapturePatternNode)
-  end
-  def copy(value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3229
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, target: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3252
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3275
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3270
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3263
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader target: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3260
-  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//lib/prism/node.rb#3293
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3257
-  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//lib/prism/node.rb#3303
-    def type; end
-  end
-end
-
-# Represents the use of a case statement for pattern matching.
-#
-#     case true
-#     in false
-#     end
-#     ^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3323
-class Prism::CaseMatchNode < ::Prism::Node
-  # def initialize: (Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
-  #
-  # @return [CaseMatchNode] a new instance of CaseMatchNode
-  #
-  # source://prism//lib/prism/node.rb#3325
-  sig do
-    params(
-      source: Prism::Source,
-      predicate: T.nilable(Prism::Node),
-      conditions: T::Array[Prism::Node],
-      consequent: T.nilable(Prism::ElseNode),
-      case_keyword_loc: Prism::Location,
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3440
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3336
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def case_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3396
-  sig { returns(String) }
-  def case_keyword; end
-
-  # attr_reader case_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3382
-  sig { returns(Prism::Location) }
-  def case_keyword_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3341
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3355
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3346
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader conditions: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#3376
-  sig { returns(T::Array[Prism::Node]) }
-  def conditions; end
-
-  # attr_reader consequent: ElseNode?
-  #
-  # source://prism//lib/prism/node.rb#3379
-  sig { returns(T.nilable(Prism::ElseNode)) }
-  def consequent; end
-
-  # def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseMatchNode
-  #
-  # source://prism//lib/prism/node.rb#3360
-  sig do
-    params(
-      predicate: T.nilable(Prism::Node),
-      conditions: T::Array[Prism::Node],
-      consequent: T.nilable(Prism::ElseNode),
-      case_keyword_loc: Prism::Location,
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::CaseMatchNode)
-  end
-  def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3341
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3368
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3401
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3389
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3406
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader predicate: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#3373
-  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//lib/prism/node.rb#3424
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#3434
-    def type; end
-  end
-end
-
-# Represents the use of a case statement.
-#
-#     case true
-#     when false
-#     end
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3457
-class Prism::CaseNode < ::Prism::Node
-  # def initialize: (Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
-  #
-  # @return [CaseNode] a new instance of CaseNode
-  #
-  # source://prism//lib/prism/node.rb#3459
-  sig do
-    params(
-      source: Prism::Source,
-      predicate: T.nilable(Prism::Node),
-      conditions: T::Array[Prism::Node],
-      consequent: T.nilable(Prism::ElseNode),
-      case_keyword_loc: Prism::Location,
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3574
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3470
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def case_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3530
-  sig { returns(String) }
-  def case_keyword; end
-
-  # attr_reader case_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3516
-  sig { returns(Prism::Location) }
-  def case_keyword_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3475
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3489
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3480
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader conditions: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#3510
-  sig { returns(T::Array[Prism::Node]) }
-  def conditions; end
-
-  # attr_reader consequent: ElseNode?
-  #
-  # source://prism//lib/prism/node.rb#3513
-  sig { returns(T.nilable(Prism::ElseNode)) }
-  def consequent; end
-
-  # def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseNode
-  #
-  # source://prism//lib/prism/node.rb#3494
-  sig do
-    params(
-      predicate: T.nilable(Prism::Node),
-      conditions: T::Array[Prism::Node],
-      consequent: T.nilable(Prism::ElseNode),
-      case_keyword_loc: Prism::Location,
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::CaseNode)
-  end
-  def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3475
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3502
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3535
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3523
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3540
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader predicate: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#3507
-  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//lib/prism/node.rb#3558
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#3568
-    def type; end
-  end
-end
-
-# Represents a class declaration involving the `class` keyword.
-#
-#     class Foo end
-#     ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3589
-class Prism::ClassNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, Location class_keyword_loc, Prism::node constant_path, Location? inheritance_operator_loc, Prism::node? superclass, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
-  #
-  # @return [ClassNode] a new instance of ClassNode
-  #
-  # source://prism//lib/prism/node.rb#3591
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      class_keyword_loc: Prism::Location,
-      constant_path: Prism::Node,
-      inheritance_operator_loc: T.nilable(Prism::Location),
-      superclass: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      name: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3733
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3605
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#3671
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3610
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def class_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3684
-  sig { returns(String) }
-  def class_keyword; end
-
-  # attr_reader class_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3645
-  sig { returns(Prism::Location) }
-  def class_keyword_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3624
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3615
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader constant_path: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3652
-  sig { returns(Prism::Node) }
-  def constant_path; end
-
-  # def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: Prism::node, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ClassNode
-  #
-  # source://prism//lib/prism/node.rb#3629
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      class_keyword_loc: Prism::Location,
-      constant_path: Prism::Node,
-      inheritance_operator_loc: T.nilable(Prism::Location),
-      superclass: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      name: Symbol,
-      location: Prism::Location
-    ).returns(Prism::ClassNode)
-  end
-  def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3610
-  sig { override.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: Prism::node, inheritance_operator_loc: Location?, superclass: Prism::node?, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3637
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3694
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3674
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inheritance_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#3689
-  sig { returns(T.nilable(String)) }
-  def inheritance_operator; end
-
-  # attr_reader inheritance_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#3655
-  sig { returns(T.nilable(Prism::Location)) }
-  def inheritance_operator_loc; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3699
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#3642
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#3681
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader superclass: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#3668
-  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//lib/prism/node.rb#3717
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#3727
-    def type; end
-  end
-end
-
-# Represents the use of the `&&=` operator for assignment to a class variable.
-#
-#     @@target &&= value
-#     ^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3751
-class Prism::ClassVariableAndWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#3753
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3855
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3763
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3768
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3778
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3773
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#3783
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ClassVariableAndWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3768
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3791
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#127
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3821
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#3796
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3799
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#3816
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3806
-  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//lib/prism/node.rb#3839
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3813
-  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//lib/prism/node.rb#3849
-    def type; end
-  end
-end
-
-# Represents assigning to a class variable using an operator that isn't `=`.
-#
-#     @@target += value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3868
-class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
-  #
-  # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#3870
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#3971
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3881
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#3934
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3924
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3886
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#3896
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#3891
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#3901
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).returns(Prism::ClassVariableOperatorWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#3886
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#3909
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#139
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#3937
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#3914
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#3917
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#339
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#346
-  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//lib/prism/node.rb#3955
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#3931
-  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//lib/prism/node.rb#3965
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to a class variable.
-#
-#     @@target ||= value
-#     ^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#3985
-class Prism::ClassVariableOrWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#3987
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4089
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#3997
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4002
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4012
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4007
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4017
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ClassVariableOrWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4002
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4025
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#133
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4055
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4030
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4033
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4050
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4040
-  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//lib/prism/node.rb#4073
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#4047
-  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//lib/prism/node.rb#4083
-    def type; end
-  end
-end
-
-# Represents referencing a class variable.
-#
-#     @@foo
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#4102
-class Prism::ClassVariableReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#4104
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4185
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4111
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4116
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4126
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4121
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> ClassVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#4131
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableReadNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4116
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4139
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4151
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#4148
-  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//lib/prism/node.rb#4169
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#4179
-    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//lib/prism/node.rb#4195
-class Prism::ClassVariableTargetNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#4197
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4274
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4204
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4209
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4219
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4214
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> ClassVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#4224
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableTargetNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4209
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4232
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4240
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4237
-  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//lib/prism/node.rb#4258
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#4268
-    def type; end
-  end
-end
-
-# Represents writing to a class variable.
-#
-#     @@foo = 1
-#     ^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4284
-class Prism::ClassVariableWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
-  #
-  # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4286
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4404
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4296
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4301
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4311
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4306
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ClassVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4316
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ClassVariableWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4301
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4324
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4370
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-  #
-  #     @@abc = 123     # name `@@abc`
-  #
-  #     @@_test = :test # name `@@_test`
-  #
-  # source://prism//lib/prism/node.rb#4333
-  sig { returns(Symbol) }
-  def name; end
-
-  # The location of the variable name.
-  #
-  #     @@foo = :bar
-  #     ^^^^^
-  #
-  # source://prism//lib/prism/node.rb#4339
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4365
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     @@foo = :bar
-  #           ^
-  #
-  # source://prism//lib/prism/node.rb#4358
-  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//lib/prism/node.rb#4388
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     @@foo = :bar
-  #             ^^^^
-  #
-  #     @@_xyz = 123
-  #              ^^^
-  #
-  # source://prism//lib/prism/node.rb#4352
-  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//lib/prism/node.rb#4398
-    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//lib/prism/parse_result.rb#366
-class Prism::Comment
-  abstract!
-
-  # Create a new comment object with the given location.
-  #
-  # @return [Comment] a new instance of Comment
-  #
-  # source://prism//lib/prism/parse_result.rb#371
-  sig { params(location: Prism::Location).void }
-  def initialize(location); end
-
-  # Implement the hash pattern matching interface for Comment.
-  #
-  # source://prism//lib/prism/parse_result.rb#376
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The location of this comment in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#368
-  sig { returns(Prism::Location) }
-  def location; end
-
-  # Returns the content of the comment by slicing it from the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#381
-  sig { returns(String) }
-  def slice; end
-
-  sig { abstract.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//lib/prism/compiler.rb#27
-class Prism::Compiler < ::Prism::Visitor
-  # Visit an individual node.
-  #
-  # source://prism//lib/prism/compiler.rb#29
-  sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) }
-  def visit(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AliasGlobalVariableNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_alias_global_variable_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AliasMethodNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_alias_method_node(node); end
-
-  # Visit a list of nodes.
-  #
-  # source://prism//lib/prism/compiler.rb#34
-  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) }
-  def visit_all(nodes); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AlternationPatternNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_alternation_pattern_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AndNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_and_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ArgumentsNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_arguments_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ArrayNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_array_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ArrayPatternNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_array_pattern_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AssocNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_assoc_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a AssocSplatNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_assoc_splat_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BackReferenceReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_back_reference_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BeginNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_begin_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BlockArgumentNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_block_argument_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BlockLocalVariableNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_block_local_variable_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BlockNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_block_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BlockParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_block_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BlockParametersNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_block_parameters_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a BreakNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_break_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CallAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_call_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CallNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_call_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CallOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_call_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CallOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_call_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CallTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_call_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CapturePatternNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_capture_pattern_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CaseMatchNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_case_match_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a CaseNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_case_node(node); end
-
-  # Visit the child nodes of the given node.
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  sig { params(node: Prism::Node).returns(T::Array[T.untyped]) }
-  def visit_child_nodes(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ClassVariableWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_class_variable_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantPathWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_path_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ConstantWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_constant_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a DefNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_def_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a DefinedNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_defined_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ElseNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_else_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a EmbeddedStatementsNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_embedded_statements_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a EmbeddedVariableNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_embedded_variable_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a EnsureNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_ensure_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a FalseNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_false_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a FindPatternNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_find_pattern_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a FlipFlopNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_flip_flop_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a FloatNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_float_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ForNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_for_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ForwardingArgumentsNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_forwarding_arguments_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ForwardingParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_forwarding_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ForwardingSuperNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_forwarding_super_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a GlobalVariableWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_global_variable_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a HashNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_hash_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a HashPatternNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_hash_pattern_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IfNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_if_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ImaginaryNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_imaginary_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ImplicitNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_implicit_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ImplicitRestNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_implicit_rest_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_in_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IndexAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_index_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IndexOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_index_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IndexOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_index_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IndexTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_index_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InstanceVariableWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_instance_variable_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a IntegerNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_integer_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InterpolatedMatchLastLineNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InterpolatedRegularExpressionNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InterpolatedStringNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_interpolated_string_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InterpolatedSymbolNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_interpolated_symbol_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a InterpolatedXStringNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_interpolated_x_string_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ItLocalVariableReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_it_local_variable_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ItParametersNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_it_parameters_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a KeywordHashNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_keyword_hash_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a KeywordRestParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LambdaNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_lambda_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_and_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_operator_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_or_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a LocalVariableWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_local_variable_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MatchLastLineNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_match_last_line_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MatchPredicateNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_match_predicate_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MatchRequiredNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_match_required_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MatchWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_match_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MissingNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_missing_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ModuleNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_module_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MultiTargetNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_multi_target_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a MultiWriteNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_multi_write_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a NextNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_next_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a NilNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_nil_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a NoKeywordsParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_no_keywords_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a NumberedParametersNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_numbered_parameters_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a NumberedReferenceReadNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_numbered_reference_read_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a OptionalKeywordParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a OptionalParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_optional_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a OrNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_or_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ParametersNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_parameters_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ParenthesesNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_parentheses_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a PinnedExpressionNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_pinned_expression_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a PinnedVariableNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_pinned_variable_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a PostExecutionNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_post_execution_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a PreExecutionNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_pre_execution_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ProgramNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_program_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RangeNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_range_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RationalNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_rational_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RedoNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_redo_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RegularExpressionNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_regular_expression_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RequiredKeywordParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_required_keyword_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RequiredParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_required_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RescueModifierNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_rescue_modifier_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RescueNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_rescue_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RestParameterNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_rest_parameter_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a RetryNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_retry_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ReturnNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_return_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SelfNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_self_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a ShareableConstantNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_shareable_constant_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SingletonClassNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_singleton_class_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SourceEncodingNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_source_encoding_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SourceFileNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_source_file_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SourceLineNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_source_line_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SplatNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_splat_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a StatementsNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_statements_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a StringNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_string_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SuperNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_super_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a SymbolNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_symbol_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a TrueNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_true_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a UndefNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_undef_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a UnlessNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_unless_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a UntilNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_until_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a WhenNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_when_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a WhileNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_while_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a XStringNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_x_string_node(node); end
-
-  # Visit the child nodes of the given node.
-  # Compile a YieldNode node
-  #
-  # source://prism//lib/prism/compiler.rb#39
-  def visit_yield_node(node); end
-end
-
-# Represents the use of the `&&=` operator for assignment to a constant.
-#
-#     Target &&= value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4417
-class Prism::ConstantAndWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4419
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4521
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4429
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4434
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4444
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4439
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4449
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ConstantAndWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4434
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4457
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#145
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4487
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4462
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4465
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4482
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4472
-  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//lib/prism/node.rb#4505
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#4479
-  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//lib/prism/node.rb#4515
-    def type; end
-  end
-end
-
-# Represents assigning to a constant using an operator that isn't `=`.
-#
-#     Target += value
-#     ^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4534
-class Prism::ConstantOperatorWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
-  #
-  # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4536
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4637
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4547
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4600
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4590
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4552
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4562
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4557
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4567
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).returns(Prism::ConstantOperatorWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4552
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4575
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#157
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4603
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4580
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4583
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#355
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#362
-  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//lib/prism/node.rb#4621
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#4597
-  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//lib/prism/node.rb#4631
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to a constant.
-#
-#     Target ||= value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4651
-class Prism::ConstantOrWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4653
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4755
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4663
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4668
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4678
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4673
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4683
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ConstantOrWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4668
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4691
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#151
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4721
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#4696
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4699
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4716
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4706
-  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//lib/prism/node.rb#4739
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#4713
-  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//lib/prism/node.rb#4749
-    def type; end
-  end
-end
-
-# Represents the use of the `&&=` operator for assignment to a constant path.
-#
-#     Parent::Child &&= value
-#     ^^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4768
-class Prism::ConstantPathAndWriteNode < ::Prism::Node
-  # def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4770
-  sig do
-    params(
-      source: Prism::Source,
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, target, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#4864
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4779
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4784
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4794
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4789
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#4799
-  sig do
-    params(
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathAndWriteNode)
-  end
-  def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4784
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4807
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4830
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4825
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#4815
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader target: ConstantPathNode
-  #
-  # source://prism//lib/prism/node.rb#4812
-  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//lib/prism/node.rb#4848
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#4822
-  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//lib/prism/node.rb#4858
-    def type; end
-  end
-end
-
-# Represents accessing a constant through a path of `::` operators.
-#
-#     Foo::Bar
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#4876
-class Prism::ConstantPathNode < ::Prism::Node
-  # def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
-  #
-  # @return [ConstantPathNode] a new instance of ConstantPathNode
-  #
-  # source://prism//lib/prism/node.rb#4878
-  sig do
-    params(
-      source: Prism::Source,
-      parent: T.nilable(Prism::Node),
-      name: T.nilable(Symbol),
-      delimiter_loc: Prism::Location,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, parent, name, delimiter_loc, name_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5003
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#4888
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # Previously, we had a child node on this class that contained either a
-  # constant read or a missing node. To not cause a breaking change, we
-  # continue to supply that API.
-  #
-  # source://prism//lib/prism/node_ext.rb#196
-  def child; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4893
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#4905
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#4898
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathNode
-  #
-  # source://prism//lib/prism/node.rb#4910
-  sig do
-    params(
-      parent: T.nilable(Prism::Node),
-      name: T.nilable(Symbol),
-      delimiter_loc: Prism::Location,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathNode)
-  end
-  def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#4893
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#4918
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def delimiter: () -> String
-  #
-  # source://prism//lib/prism/node.rb#4964
-  sig { returns(String) }
-  def delimiter; end
-
-  # The location of the `::` delimiter.
-  #
-  #     ::Foo
-  #     ^^
-  #
-  #     One::Two
-  #        ^^
-  #
-  # source://prism//lib/prism/node.rb#4944
-  sig { returns(Prism::Location) }
-  def delimiter_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns the full name of this constant path. For example: "Foo::Bar"
-  #
-  # source://prism//lib/prism/node_ext.rb#189
-  sig { returns(String) }
-  def full_name; end
-
-  # Returns the list of parts for the full name of this constant path.
-  # For example: [:Foo, :Bar]
-  #
-  # source://prism//lib/prism/node_ext.rb#167
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#4969
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The name of the constant being accessed. This could be `nil` in the event of a syntax error.
-  #
-  # source://prism//lib/prism/node.rb#4935
-  sig { returns(T.nilable(Symbol)) }
-  def name; end
-
-  # The location of the name of the constant.
-  #
-  #     ::Foo
-  #       ^^^
-  #
-  #     One::Two
-  #          ^^^
-  #
-  # source://prism//lib/prism/node.rb#4957
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
-  #
-  #     Foo::Bar
-  #     ^^^
-  #
-  #     self::Test
-  #     ^^^^
-  #
-  #     a.b::C
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#4932
-  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//lib/prism/node.rb#4987
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#4997
-    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//lib/prism/node_ext.rb#158
-class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
-
-# An error class raised when missing nodes are found while computing a
-# constant path's full name. For example:
-# Foo:: -> raises because the constant path is missing the last part
-#
-# source://prism//lib/prism/node_ext.rb#163
-class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError; end
-
-# Represents assigning to a constant path using an operator that isn't `=`.
-#
-#     Parent::Child += value
-#     ^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#5016
-class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
-  # def initialize: (ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
-  #
-  # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5018
-  sig do
-    params(
-      source: Prism::Source,
-      target: Prism::ConstantPathNode,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, target, binary_operator_loc, value, binary_operator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5111
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5028
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#5074
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5064
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5033
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5043
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5038
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5048
-  sig do
-    params(
-      target: Prism::ConstantPathNode,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathOperatorWriteNode)
-  end
-  def copy(target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5033
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5056
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5077
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#371
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#378
-  def operator_loc; end
-
-  # attr_reader target: ConstantPathNode
-  #
-  # source://prism//lib/prism/node.rb#5061
-  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//lib/prism/node.rb#5095
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#5071
-  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//lib/prism/node.rb#5105
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to a constant path.
-#
-#     Parent::Child ||= value
-#     ^^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#5124
-class Prism::ConstantPathOrWriteNode < ::Prism::Node
-  # def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5126
-  sig do
-    params(
-      source: Prism::Source,
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, target, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5220
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5135
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5140
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5150
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5145
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5155
-  sig do
-    params(
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathOrWriteNode)
-  end
-  def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5140
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5163
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5186
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#5181
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5171
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader target: ConstantPathNode
-  #
-  # source://prism//lib/prism/node.rb#5168
-  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//lib/prism/node.rb#5204
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#5178
-  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//lib/prism/node.rb#5214
-    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//lib/prism/node.rb#5232
-class Prism::ConstantPathTargetNode < ::Prism::Node
-  # def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
-  #
-  # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
-  #
-  # source://prism//lib/prism/node.rb#5234
-  sig do
-    params(
-      source: Prism::Source,
-      parent: T.nilable(Prism::Node),
-      name: T.nilable(Symbol),
-      delimiter_loc: Prism::Location,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, parent, name, delimiter_loc, name_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5338
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5244
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # Previously, we had a child node on this class that contained either a
-  # constant read or a missing node. To not cause a breaking change, we
-  # continue to supply that API.
-  #
-  # source://prism//lib/prism/node_ext.rb#232
-  def child; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5249
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5261
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5254
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathTargetNode
-  #
-  # source://prism//lib/prism/node.rb#5266
-  sig do
-    params(
-      parent: T.nilable(Prism::Node),
-      name: T.nilable(Symbol),
-      delimiter_loc: Prism::Location,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathTargetNode)
-  end
-  def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5249
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5274
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def delimiter: () -> String
-  #
-  # source://prism//lib/prism/node.rb#5299
-  sig { returns(String) }
-  def delimiter; end
-
-  # attr_reader delimiter_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5285
-  sig { returns(Prism::Location) }
-  def delimiter_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns the full name of this constant path. For example: "Foo::Bar"
-  #
-  # source://prism//lib/prism/node_ext.rb#225
-  sig { returns(String) }
-  def full_name; end
-
-  # Returns the list of parts for the full name of this constant path.
-  # For example: [:Foo, :Bar]
-  #
-  # source://prism//lib/prism/node_ext.rb#205
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5304
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol?
-  #
-  # source://prism//lib/prism/node.rb#5282
-  sig { returns(T.nilable(Symbol)) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5292
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # attr_reader parent: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#5279
-  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//lib/prism/node.rb#5322
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#5332
-    def type; end
-  end
-end
-
-# Represents writing to a constant path.
-#
-#     ::Foo = 1
-#     ^^^^^^^^^
-#
-#     Foo::Bar = 1
-#     ^^^^^^^^^^^^
-#
-#     ::Foo::Bar = 1
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#5357
-class Prism::ConstantPathWriteNode < ::Prism::Node
-  # def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5359
-  sig do
-    params(
-      source: Prism::Source,
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, target, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5465
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5368
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5373
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5383
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5378
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5388
-  sig do
-    params(
-      target: Prism::ConstantPathNode,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::ConstantPathWriteNode)
-  end
-  def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5373
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5396
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5431
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#5426
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     ::ABC = 123
-  #           ^
-  #
-  # source://prism//lib/prism/node.rb#5413
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # A node representing the constant path being written to.
-  #
-  #     Foo::Bar = 1
-  #     ^^^^^^^^
-  #
-  #     ::Foo = :abc
-  #     ^^^^^
-  #
-  # source://prism//lib/prism/node.rb#5407
-  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//lib/prism/node.rb#5449
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     FOO::BAR = :abc
-  #                ^^^^
-  #
-  # source://prism//lib/prism/node.rb#5423
-  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//lib/prism/node.rb#5459
-    def type; end
-  end
-end
-
-# Represents referencing a constant.
-#
-#     Foo
-#     ^^^
-#
-# source://prism//lib/prism/node.rb#5477
-class Prism::ConstantReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [ConstantReadNode] a new instance of ConstantReadNode
-  #
-  # source://prism//lib/prism/node.rb#5479
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5560
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5486
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5491
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5501
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5496
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> ConstantReadNode
-  #
-  # source://prism//lib/prism/node.rb#5506
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantReadNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5491
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5514
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns the full name of this constant. For example: "Foo"
-  #
-  # source://prism//lib/prism/node_ext.rb#133
-  sig { returns(String) }
-  def full_name; end
-
-  # Returns the list of parts for the full name of this constant.
-  # For example: [:Foo]
-  #
-  # source://prism//lib/prism/node_ext.rb#128
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5526
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#5523
-  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//lib/prism/node.rb#5544
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#5554
-    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//lib/prism/node.rb#5570
-class Prism::ConstantTargetNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [ConstantTargetNode] a new instance of ConstantTargetNode
-  #
-  # source://prism//lib/prism/node.rb#5572
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5649
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5579
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5584
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5594
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5589
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> ConstantTargetNode
-  #
-  # source://prism//lib/prism/node.rb#5599
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantTargetNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5584
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5607
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns the full name of this constant. For example: "Foo"
-  #
-  # source://prism//lib/prism/node_ext.rb#246
-  sig { returns(String) }
-  def full_name; end
-
-  # Returns the list of parts for the full name of this constant.
-  # For example: [:Foo]
-  #
-  # source://prism//lib/prism/node_ext.rb#241
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5615
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#5612
-  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//lib/prism/node.rb#5633
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#5643
-    def type; end
-  end
-end
-
-# Represents writing to a constant.
-#
-#     Foo = 1
-#     ^^^^^^^
-#
-# source://prism//lib/prism/node.rb#5659
-class Prism::ConstantWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
-  #
-  # @return [ConstantWriteNode] a new instance of ConstantWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5661
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#5779
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5671
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5676
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5686
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5681
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ConstantWriteNode
-  #
-  # source://prism//lib/prism/node.rb#5691
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ConstantWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5676
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#5699
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns the full name of this constant. For example: "Foo"
-  #
-  # source://prism//lib/prism/node_ext.rb#146
-  sig { returns(String) }
-  def full_name; end
-
-  # Returns the list of parts for the full name of this constant.
-  # For example: [:Foo]
-  #
-  # source://prism//lib/prism/node_ext.rb#141
-  sig { returns(T::Array[Symbol]) }
-  def full_name_parts; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5745
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
-  #
-  #     Foo = :bar # name `:Foo`
-  #
-  #     XYZ = 1    # name `:XYZ`
-  #
-  # source://prism//lib/prism/node.rb#5708
-  sig { returns(Symbol) }
-  def name; end
-
-  # The location of the constant name.
-  #
-  #     FOO = 1
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#5714
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#5740
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     FOO = :bar
-  #         ^
-  #
-  # source://prism//lib/prism/node.rb#5733
-  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//lib/prism/node.rb#5763
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     FOO = :bar
-  #           ^^^^
-  #
-  #     MyClass = Class.new
-  #               ^^^^^^^^^
-  #
-  # source://prism//lib/prism/node.rb#5727
-  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//lib/prism/node.rb#5773
-    def type; end
-  end
-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.for("[1]")
-#
-#     Prism::ArrayNode.new(
-#       [
-#         Prism::IntegerNode.new(
-#           Prism::IntegerBaseFlags::DECIMAL,
-#           1,
-#           Prism::Location.new(source, 1, 1),
-#           source
-#         )
-#       ],
-#       Prism::Location.new(source, 0, 1),
-#       Prism::Location.new(source, 2, 1),
-#       source
-#     )
-#
-# you could instead write:
-#
-#     source = Prism::Source.for("[1]")
-#
-#     ArrayNode(
-#       IntegerNode(Prism::IntegerBaseFlags::DECIMAL, 1, Location(source, 1, 1)), source),
-#       Location(source, 0, 1),
-#       Location(source, 2, 1),
-#       source
-#     )
-#
-# This is mostly helpful in the context of writing tests, but can also be used
-# to generate trees programmatically.
-#
-# source://prism//lib/prism/dsl.rb#42
-module Prism::DSL
-  private
-
-  # Create a new AliasGlobalVariableNode node
-  #
-  # source://prism//lib/prism/dsl.rb#51
-  def AliasGlobalVariableNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new AliasMethodNode node
-  #
-  # source://prism//lib/prism/dsl.rb#56
-  def AliasMethodNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new AlternationPatternNode node
-  #
-  # source://prism//lib/prism/dsl.rb#61
-  def AlternationPatternNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new AndNode node
-  #
-  # source://prism//lib/prism/dsl.rb#66
-  def AndNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ArgumentsNode node
-  #
-  # source://prism//lib/prism/dsl.rb#71
-  def ArgumentsNode(flags, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ArrayNode node
-  #
-  # source://prism//lib/prism/dsl.rb#76
-  def ArrayNode(flags, elements, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ArrayPatternNode node
-  #
-  # source://prism//lib/prism/dsl.rb#81
-  def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new AssocNode node
-  #
-  # source://prism//lib/prism/dsl.rb#86
-  def AssocNode(key, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new AssocSplatNode node
-  #
-  # source://prism//lib/prism/dsl.rb#91
-  def AssocSplatNode(value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BackReferenceReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#96
-  def BackReferenceReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BeginNode node
-  #
-  # source://prism//lib/prism/dsl.rb#101
-  def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BlockArgumentNode node
-  #
-  # source://prism//lib/prism/dsl.rb#106
-  def BlockArgumentNode(expression, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BlockLocalVariableNode node
-  #
-  # source://prism//lib/prism/dsl.rb#111
-  def BlockLocalVariableNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BlockNode node
-  #
-  # source://prism//lib/prism/dsl.rb#116
-  def BlockNode(locals, parameters, body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BlockParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#121
-  def BlockParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BlockParametersNode node
-  #
-  # source://prism//lib/prism/dsl.rb#126
-  def BlockParametersNode(parameters, locals, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new BreakNode node
-  #
-  # source://prism//lib/prism/dsl.rb#131
-  def BreakNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CallAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#136
-  def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CallNode node
-  #
-  # source://prism//lib/prism/dsl.rb#141
-  def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CallOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#146
-  def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CallOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#151
-  def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CallTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#156
-  def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CapturePatternNode node
-  #
-  # source://prism//lib/prism/dsl.rb#161
-  def CapturePatternNode(value, target, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CaseMatchNode node
-  #
-  # source://prism//lib/prism/dsl.rb#166
-  def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new CaseNode node
-  #
-  # source://prism//lib/prism/dsl.rb#171
-  def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassNode node
-  #
-  # source://prism//lib/prism/dsl.rb#176
-  def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#181
-  def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#186
-  def ClassVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#191
-  def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#196
-  def ClassVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#201
-  def ClassVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ClassVariableWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#206
-  def ClassVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#211
-  def ConstantAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#216
-  def ConstantOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#221
-  def ConstantOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#226
-  def ConstantPathAndWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathNode node
-  #
-  # source://prism//lib/prism/dsl.rb#231
-  def ConstantPathNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#236
-  def ConstantPathOperatorWriteNode(target, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#241
-  def ConstantPathOrWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#246
-  def ConstantPathTargetNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantPathWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#251
-  def ConstantPathWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#256
-  def ConstantReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#261
-  def ConstantTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ConstantWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#266
-  def ConstantWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new DefNode node
-  #
-  # source://prism//lib/prism/dsl.rb#271
-  def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new DefinedNode node
-  #
-  # source://prism//lib/prism/dsl.rb#276
-  def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ElseNode node
-  #
-  # source://prism//lib/prism/dsl.rb#281
-  def ElseNode(else_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new EmbeddedStatementsNode node
-  #
-  # source://prism//lib/prism/dsl.rb#286
-  def EmbeddedStatementsNode(opening_loc, statements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new EmbeddedVariableNode node
-  #
-  # source://prism//lib/prism/dsl.rb#291
-  def EmbeddedVariableNode(operator_loc, variable, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new EnsureNode node
-  #
-  # source://prism//lib/prism/dsl.rb#296
-  def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new FalseNode node
-  #
-  # source://prism//lib/prism/dsl.rb#301
-  def FalseNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new FindPatternNode node
-  #
-  # source://prism//lib/prism/dsl.rb#306
-  def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new FlipFlopNode node
-  #
-  # source://prism//lib/prism/dsl.rb#311
-  def FlipFlopNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new FloatNode node
-  #
-  # source://prism//lib/prism/dsl.rb#316
-  def FloatNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ForNode node
-  #
-  # source://prism//lib/prism/dsl.rb#321
-  def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ForwardingArgumentsNode node
-  #
-  # source://prism//lib/prism/dsl.rb#326
-  def ForwardingArgumentsNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ForwardingParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#331
-  def ForwardingParameterNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ForwardingSuperNode node
-  #
-  # source://prism//lib/prism/dsl.rb#336
-  def ForwardingSuperNode(block, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#341
-  def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#346
-  def GlobalVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#351
-  def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#356
-  def GlobalVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#361
-  def GlobalVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new GlobalVariableWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#366
-  def GlobalVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new HashNode node
-  #
-  # source://prism//lib/prism/dsl.rb#371
-  def HashNode(opening_loc, elements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new HashPatternNode node
-  #
-  # source://prism//lib/prism/dsl.rb#376
-  def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IfNode node
-  #
-  # source://prism//lib/prism/dsl.rb#381
-  def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ImaginaryNode node
-  #
-  # source://prism//lib/prism/dsl.rb#386
-  def ImaginaryNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ImplicitNode node
-  #
-  # source://prism//lib/prism/dsl.rb#391
-  def ImplicitNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ImplicitRestNode node
-  #
-  # source://prism//lib/prism/dsl.rb#396
-  def ImplicitRestNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InNode node
-  #
-  # source://prism//lib/prism/dsl.rb#401
-  def InNode(pattern, statements, in_loc, then_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IndexAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#406
-  def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IndexOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#411
-  def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IndexOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#416
-  def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IndexTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#421
-  def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#426
-  def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#431
-  def InstanceVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#436
-  def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#441
-  def InstanceVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#446
-  def InstanceVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InstanceVariableWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#451
-  def InstanceVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new IntegerNode node
-  #
-  # source://prism//lib/prism/dsl.rb#456
-  def IntegerNode(flags, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InterpolatedMatchLastLineNode node
-  #
-  # source://prism//lib/prism/dsl.rb#461
-  def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InterpolatedRegularExpressionNode node
-  #
-  # source://prism//lib/prism/dsl.rb#466
-  def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InterpolatedStringNode node
-  #
-  # source://prism//lib/prism/dsl.rb#471
-  def InterpolatedStringNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InterpolatedSymbolNode node
-  #
-  # source://prism//lib/prism/dsl.rb#476
-  def InterpolatedSymbolNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new InterpolatedXStringNode node
-  #
-  # source://prism//lib/prism/dsl.rb#481
-  def InterpolatedXStringNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ItLocalVariableReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#486
-  def ItLocalVariableReadNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ItParametersNode node
-  #
-  # source://prism//lib/prism/dsl.rb#491
-  def ItParametersNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new KeywordHashNode node
-  #
-  # source://prism//lib/prism/dsl.rb#496
-  def KeywordHashNode(flags, elements, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new KeywordRestParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#501
-  def KeywordRestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LambdaNode node
-  #
-  # source://prism//lib/prism/dsl.rb#506
-  def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#511
-  def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#516
-  def LocalVariableOperatorWriteNode(name_loc, binary_operator_loc, value, name, binary_operator, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#521
-  def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#526
-  def LocalVariableReadNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#531
-  def LocalVariableTargetNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new LocalVariableWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#536
-  def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new Location object
-  #
-  # source://prism//lib/prism/dsl.rb#46
-  def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end
-
-  # Create a new MatchLastLineNode node
-  #
-  # source://prism//lib/prism/dsl.rb#541
-  def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MatchPredicateNode node
-  #
-  # source://prism//lib/prism/dsl.rb#546
-  def MatchPredicateNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MatchRequiredNode node
-  #
-  # source://prism//lib/prism/dsl.rb#551
-  def MatchRequiredNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MatchWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#556
-  def MatchWriteNode(call, targets, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MissingNode node
-  #
-  # source://prism//lib/prism/dsl.rb#561
-  def MissingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ModuleNode node
-  #
-  # source://prism//lib/prism/dsl.rb#566
-  def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MultiTargetNode node
-  #
-  # source://prism//lib/prism/dsl.rb#571
-  def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new MultiWriteNode node
-  #
-  # source://prism//lib/prism/dsl.rb#576
-  def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new NextNode node
-  #
-  # source://prism//lib/prism/dsl.rb#581
-  def NextNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new NilNode node
-  #
-  # source://prism//lib/prism/dsl.rb#586
-  def NilNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new NoKeywordsParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#591
-  def NoKeywordsParameterNode(operator_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new NumberedParametersNode node
-  #
-  # source://prism//lib/prism/dsl.rb#596
-  def NumberedParametersNode(maximum, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new NumberedReferenceReadNode node
-  #
-  # source://prism//lib/prism/dsl.rb#601
-  def NumberedReferenceReadNode(number, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new OptionalKeywordParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#606
-  def OptionalKeywordParameterNode(flags, name, name_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new OptionalParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#611
-  def OptionalParameterNode(flags, name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new OrNode node
-  #
-  # source://prism//lib/prism/dsl.rb#616
-  def OrNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ParametersNode node
-  #
-  # source://prism//lib/prism/dsl.rb#621
-  def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ParenthesesNode node
-  #
-  # source://prism//lib/prism/dsl.rb#626
-  def ParenthesesNode(body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new PinnedExpressionNode node
-  #
-  # source://prism//lib/prism/dsl.rb#631
-  def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new PinnedVariableNode node
-  #
-  # source://prism//lib/prism/dsl.rb#636
-  def PinnedVariableNode(variable, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new PostExecutionNode node
-  #
-  # source://prism//lib/prism/dsl.rb#641
-  def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new PreExecutionNode node
-  #
-  # source://prism//lib/prism/dsl.rb#646
-  def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ProgramNode node
-  #
-  # source://prism//lib/prism/dsl.rb#651
-  def ProgramNode(locals, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RangeNode node
-  #
-  # source://prism//lib/prism/dsl.rb#656
-  def RangeNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RationalNode node
-  #
-  # source://prism//lib/prism/dsl.rb#661
-  def RationalNode(flags, numerator, denominator, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RedoNode node
-  #
-  # source://prism//lib/prism/dsl.rb#666
-  def RedoNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RegularExpressionNode node
-  #
-  # source://prism//lib/prism/dsl.rb#671
-  def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RequiredKeywordParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#676
-  def RequiredKeywordParameterNode(flags, name, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RequiredParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#681
-  def RequiredParameterNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RescueModifierNode node
-  #
-  # source://prism//lib/prism/dsl.rb#686
-  def RescueModifierNode(expression, keyword_loc, rescue_expression, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RescueNode node
-  #
-  # source://prism//lib/prism/dsl.rb#691
-  def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RestParameterNode node
-  #
-  # source://prism//lib/prism/dsl.rb#696
-  def RestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new RetryNode node
-  #
-  # source://prism//lib/prism/dsl.rb#701
-  def RetryNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ReturnNode node
-  #
-  # source://prism//lib/prism/dsl.rb#706
-  def ReturnNode(flags, keyword_loc, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SelfNode node
-  #
-  # source://prism//lib/prism/dsl.rb#711
-  def SelfNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new ShareableConstantNode node
-  #
-  # source://prism//lib/prism/dsl.rb#716
-  def ShareableConstantNode(flags, write, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SingletonClassNode node
-  #
-  # source://prism//lib/prism/dsl.rb#721
-  def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SourceEncodingNode node
-  #
-  # source://prism//lib/prism/dsl.rb#726
-  def SourceEncodingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SourceFileNode node
-  #
-  # source://prism//lib/prism/dsl.rb#731
-  def SourceFileNode(flags, filepath, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SourceLineNode node
-  #
-  # source://prism//lib/prism/dsl.rb#736
-  def SourceLineNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SplatNode node
-  #
-  # source://prism//lib/prism/dsl.rb#741
-  def SplatNode(operator_loc, expression, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new StatementsNode node
-  #
-  # source://prism//lib/prism/dsl.rb#746
-  def StatementsNode(body, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new StringNode node
-  #
-  # source://prism//lib/prism/dsl.rb#751
-  def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SuperNode node
-  #
-  # source://prism//lib/prism/dsl.rb#756
-  def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new SymbolNode node
-  #
-  # source://prism//lib/prism/dsl.rb#761
-  def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new TrueNode node
-  #
-  # source://prism//lib/prism/dsl.rb#766
-  def TrueNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new UndefNode node
-  #
-  # source://prism//lib/prism/dsl.rb#771
-  def UndefNode(names, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new UnlessNode node
-  #
-  # source://prism//lib/prism/dsl.rb#776
-  def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new UntilNode node
-  #
-  # source://prism//lib/prism/dsl.rb#781
-  def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new WhenNode node
-  #
-  # source://prism//lib/prism/dsl.rb#786
-  def WhenNode(keyword_loc, conditions, then_keyword_loc, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new WhileNode node
-  #
-  # source://prism//lib/prism/dsl.rb#791
-  def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new XStringNode node
-  #
-  # source://prism//lib/prism/dsl.rb#796
-  def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
-
-  # Create a new YieldNode node
-  #
-  # source://prism//lib/prism/dsl.rb#801
-  def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
-end
-
-# Represents a method definition.
-#
-#     def method
-#     end
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#5793
-class Prism::DefNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Prism::node? receiver, ParametersNode? parameters, Prism::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//lib/prism/node.rb#5795
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      receiver: T.nilable(Prism::Node),
-      parameters: T.nilable(Prism::ParametersNode),
-      body: T.nilable(Prism::Node),
-      locals: T::Array[Symbol],
-      def_keyword_loc: Prism::Location,
-      operator_loc: T.nilable(Prism::Location),
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      equal_loc: T.nilable(Prism::Location),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6008
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#5813
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#5866
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5818
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#5832
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#5823
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: Prism::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) -> DefNode
-  #
-  # source://prism//lib/prism/node.rb#5837
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      receiver: T.nilable(Prism::Node),
-      parameters: T.nilable(Prism::ParametersNode),
-      body: T.nilable(Prism::Node),
-      locals: T::Array[Symbol],
-      def_keyword_loc: Prism::Location,
-      operator_loc: T.nilable(Prism::Location),
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      equal_loc: T.nilable(Prism::Location),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::DefNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#5818
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: Prism::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//lib/prism/node.rb#5845
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def def_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#5944
-  sig { returns(String) }
-  def def_keyword; end
-
-  # attr_reader def_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5872
-  sig { returns(Prism::Location) }
-  def def_keyword_loc; end
-
-  # def end_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#5969
-  sig { returns(T.nilable(String)) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#5931
-  sig { returns(T.nilable(Prism::Location)) }
-  def end_keyword_loc; end
-
-  # def equal: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#5964
-  sig { returns(T.nilable(String)) }
-  def equal; end
-
-  # attr_reader equal_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#5918
-  sig { returns(T.nilable(Prism::Location)) }
-  def equal_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#5974
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#5869
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#5954
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#5892
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#5850
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#5853
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#5949
-  sig { returns(T.nilable(String)) }
-  def operator; end
-
-  # attr_reader operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#5879
-  sig { returns(T.nilable(Prism::Location)) }
-  def operator_loc; end
-
-  # attr_reader parameters: ParametersNode?
-  #
-  # source://prism//lib/prism/node.rb#5863
-  sig { returns(T.nilable(Prism::ParametersNode)) }
-  def parameters; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#5860
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#5959
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#5905
-  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//lib/prism/node.rb#5992
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6002
-    def type; end
-  end
-end
-
-# Represents the use of the `defined?` keyword.
-#
-#     defined?(a)
-#     ^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#6030
-class Prism::DefinedNode < ::Prism::Node
-  # def initialize: (Location? lparen_loc, Prism::node value, Location? rparen_loc, Location keyword_loc, Location location) -> void
-  #
-  # @return [DefinedNode] a new instance of DefinedNode
-  #
-  # source://prism//lib/prism/node.rb#6032
-  sig do
-    params(
-      source: Prism::Source,
-      lparen_loc: T.nilable(Prism::Location),
-      value: Prism::Node,
-      rparen_loc: T.nilable(Prism::Location),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, lparen_loc, value, rparen_loc, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6160
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6042
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6047
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6057
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6052
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location, ?location: Location) -> DefinedNode
-  #
-  # source://prism//lib/prism/node.rb#6062
-  sig do
-    params(
-      lparen_loc: T.nilable(Prism::Location),
-      value: Prism::Node,
-      rparen_loc: T.nilable(Prism::Location),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::DefinedNode)
-  end
-  def copy(lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6047
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#6070
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6126
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6121
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6104
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#6111
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#6075
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#6116
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#6091
-  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//lib/prism/node.rb#6144
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#6088
-  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//lib/prism/node.rb#6154
-    def type; end
-  end
-end
-
-# source://prism//lib/prism/desugar_compiler.rb#4
-class Prism::DesugarAndWriteNode
-  # @return [DesugarAndWriteNode] a new instance of DesugarAndWriteNode
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#7
-  def initialize(node, source, read_class, write_class, *arguments); end
-
-  # Returns the value of attribute arguments.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#5
-  def arguments; end
-
-  # Desugar `x &&= y` to `x && x = y`
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#16
-  def compile; end
-
-  # Returns the value of attribute node.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#5
-  def node; end
-
-  # Returns the value of attribute read_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#5
-  def read_class; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#5
-  def source; end
-
-  # Returns the value of attribute write_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#5
-  def write_class; 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//lib/prism/desugar_compiler.rb#218
-class Prism::DesugarCompiler < ::Prism::MutationCompiler
-  # @@foo &&= bar
-  #
-  # becomes
-  #
-  # @@foo && @@foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#224
-  def visit_class_variable_and_write_node(node); end
-
-  # @@foo += bar
-  #
-  # becomes
-  #
-  # @@foo = @@foo + bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#242
-  def visit_class_variable_operator_write_node(node); end
-
-  # @@foo ||= bar
-  #
-  # becomes
-  #
-  # defined?(@@foo) ? @@foo : @@foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#233
-  def visit_class_variable_or_write_node(node); end
-
-  # Foo &&= bar
-  #
-  # becomes
-  #
-  # Foo && Foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#251
-  def visit_constant_and_write_node(node); end
-
-  # Foo += bar
-  #
-  # becomes
-  #
-  # Foo = Foo + bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#269
-  def visit_constant_operator_write_node(node); end
-
-  # Foo ||= bar
-  #
-  # becomes
-  #
-  # defined?(Foo) ? Foo : Foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#260
-  def visit_constant_or_write_node(node); end
-
-  # $foo &&= bar
-  #
-  # becomes
-  #
-  # $foo && $foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#278
-  def visit_global_variable_and_write_node(node); end
-
-  # $foo += bar
-  #
-  # becomes
-  #
-  # $foo = $foo + bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#296
-  def visit_global_variable_operator_write_node(node); end
-
-  # $foo ||= bar
-  #
-  # becomes
-  #
-  # defined?($foo) ? $foo : $foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#287
-  def visit_global_variable_or_write_node(node); end
-
-  # becomes
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#305
-  def visit_instance_variable_and_write_node(node); end
-
-  # becomes
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#323
-  def visit_instance_variable_operator_write_node(node); end
-
-  # becomes
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#314
-  def visit_instance_variable_or_write_node(node); end
-
-  # foo &&= bar
-  #
-  # becomes
-  #
-  # foo && foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#332
-  def visit_local_variable_and_write_node(node); end
-
-  # foo += bar
-  #
-  # becomes
-  #
-  # foo = foo + bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#350
-  def visit_local_variable_operator_write_node(node); end
-
-  # foo ||= bar
-  #
-  # becomes
-  #
-  # foo || foo = bar
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#341
-  def visit_local_variable_or_write_node(node); end
-end
-
-# source://prism//lib/prism/desugar_compiler.rb#63
-class Prism::DesugarOperatorWriteNode
-  # @return [DesugarOperatorWriteNode] a new instance of DesugarOperatorWriteNode
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#66
-  def initialize(node, source, read_class, write_class, *arguments); end
-
-  # Returns the value of attribute arguments.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#64
-  def arguments; end
-
-  # Desugar `x += y` to `x = x + y`
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#75
-  def compile; end
-
-  # Returns the value of attribute node.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#64
-  def node; end
-
-  # Returns the value of attribute read_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#64
-  def read_class; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#64
-  def source; end
-
-  # Returns the value of attribute write_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#64
-  def write_class; end
-end
-
-# source://prism//lib/prism/desugar_compiler.rb#27
-class Prism::DesugarOrWriteDefinedNode
-  # @return [DesugarOrWriteDefinedNode] a new instance of DesugarOrWriteDefinedNode
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#30
-  def initialize(node, source, read_class, write_class, *arguments); end
-
-  # Returns the value of attribute arguments.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#28
-  def arguments; end
-
-  # Desugar `x ||= y` to `defined?(x) ? x : x = y`
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#39
-  def compile; end
-
-  # Returns the value of attribute node.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#28
-  def node; end
-
-  # Returns the value of attribute read_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#28
-  def read_class; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#28
-  def source; end
-
-  # Returns the value of attribute write_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#28
-  def write_class; end
-end
-
-# source://prism//lib/prism/desugar_compiler.rb#101
-class Prism::DesugarOrWriteNode
-  # @return [DesugarOrWriteNode] a new instance of DesugarOrWriteNode
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#104
-  def initialize(node, source, read_class, write_class, *arguments); end
-
-  # Returns the value of attribute arguments.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#102
-  def arguments; end
-
-  # Desugar `x ||= y` to `x || x = y`
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#113
-  def compile; end
-
-  # Returns the value of attribute node.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#102
-  def node; end
-
-  # Returns the value of attribute read_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#102
-  def read_class; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#102
-  def source; end
-
-  # Returns the value of attribute write_class.
-  #
-  # source://prism//lib/prism/desugar_compiler.rb#102
-  def write_class; 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//lib/prism/dispatcher.rb#41
-class Prism::Dispatcher < ::Prism::Visitor
-  # Initialize a new dispatcher.
-  #
-  # @return [Dispatcher] a new instance of Dispatcher
-  #
-  # source://prism//lib/prism/dispatcher.rb#46
-  def initialize; end
-
-  # Walks `root` dispatching events to all registered listeners.
-  #
-  # def dispatch: (Node) -> void
-  #
-  # source://prism//lib/prism/visitor.rb#17
-  def dispatch(node); end
-
-  # Dispatches a single event for `node` to all registered listeners.
-  #
-  # def dispatch_once: (Node) -> void
-  #
-  # source://prism//lib/prism/dispatcher.rb#65
-  def dispatch_once(node); end
-
-  # attr_reader listeners: Hash[Symbol, Array[Listener]]
-  #
-  # source://prism//lib/prism/dispatcher.rb#43
-  def listeners; end
-
-  # Register a listener for one or more events.
-  #
-  # def register: (Listener, *Symbol) -> void
-  #
-  # source://prism//lib/prism/dispatcher.rb#53
-  def register(listener, *events); end
-
-  # Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#71
-  def visit_alias_global_variable_node(node); end
-
-  # Dispatch enter and leave events for AliasMethodNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#79
-  def visit_alias_method_node(node); end
-
-  # Dispatch enter and leave events for AlternationPatternNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#87
-  def visit_alternation_pattern_node(node); end
-
-  # Dispatch enter and leave events for AndNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#95
-  def visit_and_node(node); end
-
-  # Dispatch enter and leave events for ArgumentsNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#103
-  def visit_arguments_node(node); end
-
-  # Dispatch enter and leave events for ArrayNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#111
-  def visit_array_node(node); end
-
-  # Dispatch enter and leave events for ArrayPatternNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#119
-  def visit_array_pattern_node(node); end
-
-  # Dispatch enter and leave events for AssocNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#127
-  def visit_assoc_node(node); end
-
-  # Dispatch enter and leave events for AssocSplatNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#135
-  def visit_assoc_splat_node(node); end
-
-  # Dispatch enter and leave events for BackReferenceReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#143
-  def visit_back_reference_read_node(node); end
-
-  # Dispatch enter and leave events for BeginNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#151
-  def visit_begin_node(node); end
-
-  # Dispatch enter and leave events for BlockArgumentNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#159
-  def visit_block_argument_node(node); end
-
-  # Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#167
-  def visit_block_local_variable_node(node); end
-
-  # Dispatch enter and leave events for BlockNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#175
-  def visit_block_node(node); end
-
-  # Dispatch enter and leave events for BlockParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#183
-  def visit_block_parameter_node(node); end
-
-  # Dispatch enter and leave events for BlockParametersNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#191
-  def visit_block_parameters_node(node); end
-
-  # Dispatch enter and leave events for BreakNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#199
-  def visit_break_node(node); end
-
-  # Dispatch enter and leave events for CallAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#207
-  def visit_call_and_write_node(node); end
-
-  # Dispatch enter and leave events for CallNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#215
-  def visit_call_node(node); end
-
-  # Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#223
-  def visit_call_operator_write_node(node); end
-
-  # Dispatch enter and leave events for CallOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#231
-  def visit_call_or_write_node(node); end
-
-  # Dispatch enter and leave events for CallTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#239
-  def visit_call_target_node(node); end
-
-  # Dispatch enter and leave events for CapturePatternNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#247
-  def visit_capture_pattern_node(node); end
-
-  # Dispatch enter and leave events for CaseMatchNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#255
-  def visit_case_match_node(node); end
-
-  # Dispatch enter and leave events for CaseNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#263
-  def visit_case_node(node); end
-
-  # Dispatch enter and leave events for ClassNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#271
-  def visit_class_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#279
-  def visit_class_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#287
-  def visit_class_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#295
-  def visit_class_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#303
-  def visit_class_variable_read_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#311
-  def visit_class_variable_target_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#319
-  def visit_class_variable_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#327
-  def visit_constant_and_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#335
-  def visit_constant_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#343
-  def visit_constant_or_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#351
-  def visit_constant_path_and_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#359
-  def visit_constant_path_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#367
-  def visit_constant_path_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#375
-  def visit_constant_path_or_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#383
-  def visit_constant_path_target_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#391
-  def visit_constant_path_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#399
-  def visit_constant_read_node(node); end
-
-  # Dispatch enter and leave events for ConstantTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#407
-  def visit_constant_target_node(node); end
-
-  # Dispatch enter and leave events for ConstantWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#415
-  def visit_constant_write_node(node); end
-
-  # Dispatch enter and leave events for DefNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#423
-  def visit_def_node(node); end
-
-  # Dispatch enter and leave events for DefinedNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#431
-  def visit_defined_node(node); end
-
-  # Dispatch enter and leave events for ElseNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#439
-  def visit_else_node(node); end
-
-  # Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#447
-  def visit_embedded_statements_node(node); end
-
-  # Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#455
-  def visit_embedded_variable_node(node); end
-
-  # Dispatch enter and leave events for EnsureNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#463
-  def visit_ensure_node(node); end
-
-  # Dispatch enter and leave events for FalseNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#471
-  def visit_false_node(node); end
-
-  # Dispatch enter and leave events for FindPatternNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#479
-  def visit_find_pattern_node(node); end
-
-  # Dispatch enter and leave events for FlipFlopNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#487
-  def visit_flip_flop_node(node); end
-
-  # Dispatch enter and leave events for FloatNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#495
-  def visit_float_node(node); end
-
-  # Dispatch enter and leave events for ForNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#503
-  def visit_for_node(node); end
-
-  # Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#511
-  def visit_forwarding_arguments_node(node); end
-
-  # Dispatch enter and leave events for ForwardingParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#519
-  def visit_forwarding_parameter_node(node); end
-
-  # Dispatch enter and leave events for ForwardingSuperNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#527
-  def visit_forwarding_super_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#535
-  def visit_global_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#543
-  def visit_global_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#551
-  def visit_global_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#559
-  def visit_global_variable_read_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#567
-  def visit_global_variable_target_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#575
-  def visit_global_variable_write_node(node); end
-
-  # Dispatch enter and leave events for HashNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#583
-  def visit_hash_node(node); end
-
-  # Dispatch enter and leave events for HashPatternNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#591
-  def visit_hash_pattern_node(node); end
-
-  # Dispatch enter and leave events for IfNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#599
-  def visit_if_node(node); end
-
-  # Dispatch enter and leave events for ImaginaryNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#607
-  def visit_imaginary_node(node); end
-
-  # Dispatch enter and leave events for ImplicitNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#615
-  def visit_implicit_node(node); end
-
-  # Dispatch enter and leave events for ImplicitRestNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#623
-  def visit_implicit_rest_node(node); end
-
-  # Dispatch enter and leave events for InNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#631
-  def visit_in_node(node); end
-
-  # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#639
-  def visit_index_and_write_node(node); end
-
-  # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#647
-  def visit_index_operator_write_node(node); end
-
-  # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#655
-  def visit_index_or_write_node(node); end
-
-  # Dispatch enter and leave events for IndexTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#663
-  def visit_index_target_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#671
-  def visit_instance_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#679
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#687
-  def visit_instance_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#695
-  def visit_instance_variable_read_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#703
-  def visit_instance_variable_target_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#711
-  def visit_instance_variable_write_node(node); end
-
-  # Dispatch enter and leave events for IntegerNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#719
-  def visit_integer_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#727
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#735
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedStringNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#743
-  def visit_interpolated_string_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#751
-  def visit_interpolated_symbol_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#759
-  def visit_interpolated_x_string_node(node); end
-
-  # Dispatch enter and leave events for ItLocalVariableReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#767
-  def visit_it_local_variable_read_node(node); end
-
-  # Dispatch enter and leave events for ItParametersNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#775
-  def visit_it_parameters_node(node); end
-
-  # Dispatch enter and leave events for KeywordHashNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#783
-  def visit_keyword_hash_node(node); end
-
-  # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#791
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Dispatch enter and leave events for LambdaNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#799
-  def visit_lambda_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#807
-  def visit_local_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#815
-  def visit_local_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#823
-  def visit_local_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#831
-  def visit_local_variable_read_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#839
-  def visit_local_variable_target_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#847
-  def visit_local_variable_write_node(node); end
-
-  # Dispatch enter and leave events for MatchLastLineNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#855
-  def visit_match_last_line_node(node); end
-
-  # Dispatch enter and leave events for MatchPredicateNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#863
-  def visit_match_predicate_node(node); end
-
-  # Dispatch enter and leave events for MatchRequiredNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#871
-  def visit_match_required_node(node); end
-
-  # Dispatch enter and leave events for MatchWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#879
-  def visit_match_write_node(node); end
-
-  # Dispatch enter and leave events for MissingNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#887
-  def visit_missing_node(node); end
-
-  # Dispatch enter and leave events for ModuleNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#895
-  def visit_module_node(node); end
-
-  # Dispatch enter and leave events for MultiTargetNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#903
-  def visit_multi_target_node(node); end
-
-  # Dispatch enter and leave events for MultiWriteNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#911
-  def visit_multi_write_node(node); end
-
-  # Dispatch enter and leave events for NextNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#919
-  def visit_next_node(node); end
-
-  # Dispatch enter and leave events for NilNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#927
-  def visit_nil_node(node); end
-
-  # Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#935
-  def visit_no_keywords_parameter_node(node); end
-
-  # Dispatch enter and leave events for NumberedParametersNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#943
-  def visit_numbered_parameters_node(node); end
-
-  # Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#951
-  def visit_numbered_reference_read_node(node); end
-
-  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#959
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Dispatch enter and leave events for OptionalParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#967
-  def visit_optional_parameter_node(node); end
-
-  # Dispatch enter and leave events for OrNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#975
-  def visit_or_node(node); end
-
-  # Dispatch enter and leave events for ParametersNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#983
-  def visit_parameters_node(node); end
-
-  # Dispatch enter and leave events for ParenthesesNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#991
-  def visit_parentheses_node(node); end
-
-  # Dispatch enter and leave events for PinnedExpressionNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#999
-  def visit_pinned_expression_node(node); end
-
-  # Dispatch enter and leave events for PinnedVariableNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1007
-  def visit_pinned_variable_node(node); end
-
-  # Dispatch enter and leave events for PostExecutionNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1015
-  def visit_post_execution_node(node); end
-
-  # Dispatch enter and leave events for PreExecutionNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1023
-  def visit_pre_execution_node(node); end
-
-  # Dispatch enter and leave events for ProgramNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1031
-  def visit_program_node(node); end
-
-  # Dispatch enter and leave events for RangeNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1039
-  def visit_range_node(node); end
-
-  # Dispatch enter and leave events for RationalNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1047
-  def visit_rational_node(node); end
-
-  # Dispatch enter and leave events for RedoNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1055
-  def visit_redo_node(node); end
-
-  # Dispatch enter and leave events for RegularExpressionNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1063
-  def visit_regular_expression_node(node); end
-
-  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1071
-  def visit_required_keyword_parameter_node(node); end
-
-  # Dispatch enter and leave events for RequiredParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1079
-  def visit_required_parameter_node(node); end
-
-  # Dispatch enter and leave events for RescueModifierNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1087
-  def visit_rescue_modifier_node(node); end
-
-  # Dispatch enter and leave events for RescueNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1095
-  def visit_rescue_node(node); end
-
-  # Dispatch enter and leave events for RestParameterNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1103
-  def visit_rest_parameter_node(node); end
-
-  # Dispatch enter and leave events for RetryNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1111
-  def visit_retry_node(node); end
-
-  # Dispatch enter and leave events for ReturnNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1119
-  def visit_return_node(node); end
-
-  # Dispatch enter and leave events for SelfNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1127
-  def visit_self_node(node); end
-
-  # Dispatch enter and leave events for ShareableConstantNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1135
-  def visit_shareable_constant_node(node); end
-
-  # Dispatch enter and leave events for SingletonClassNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1143
-  def visit_singleton_class_node(node); end
-
-  # Dispatch enter and leave events for SourceEncodingNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1151
-  def visit_source_encoding_node(node); end
-
-  # Dispatch enter and leave events for SourceFileNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1159
-  def visit_source_file_node(node); end
-
-  # Dispatch enter and leave events for SourceLineNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1167
-  def visit_source_line_node(node); end
-
-  # Dispatch enter and leave events for SplatNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1175
-  def visit_splat_node(node); end
-
-  # Dispatch enter and leave events for StatementsNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1183
-  def visit_statements_node(node); end
-
-  # Dispatch enter and leave events for StringNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1191
-  def visit_string_node(node); end
-
-  # Dispatch enter and leave events for SuperNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1199
-  def visit_super_node(node); end
-
-  # Dispatch enter and leave events for SymbolNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1207
-  def visit_symbol_node(node); end
-
-  # Dispatch enter and leave events for TrueNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1215
-  def visit_true_node(node); end
-
-  # Dispatch enter and leave events for UndefNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1223
-  def visit_undef_node(node); end
-
-  # Dispatch enter and leave events for UnlessNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1231
-  def visit_unless_node(node); end
-
-  # Dispatch enter and leave events for UntilNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1239
-  def visit_until_node(node); end
-
-  # Dispatch enter and leave events for WhenNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1247
-  def visit_when_node(node); end
-
-  # Dispatch enter and leave events for WhileNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1255
-  def visit_while_node(node); end
-
-  # Dispatch enter and leave events for XStringNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1263
-  def visit_x_string_node(node); end
-
-  # Dispatch enter and leave events for YieldNode nodes and continue
-  # walking the tree.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1271
-  def visit_yield_node(node); end
-end
-
-# source://prism//lib/prism/dispatcher.rb#1277
-class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
-  # @return [DispatchOnce] a new instance of DispatchOnce
-  #
-  # source://prism//lib/prism/dispatcher.rb#1280
-  def initialize(listeners); end
-
-  # Returns the value of attribute listeners.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1278
-  def listeners; end
-
-  # Dispatch enter and leave events for AliasGlobalVariableNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1285
-  def visit_alias_global_variable_node(node); end
-
-  # Dispatch enter and leave events for AliasMethodNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1291
-  def visit_alias_method_node(node); end
-
-  # Dispatch enter and leave events for AlternationPatternNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1297
-  def visit_alternation_pattern_node(node); end
-
-  # Dispatch enter and leave events for AndNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1303
-  def visit_and_node(node); end
-
-  # Dispatch enter and leave events for ArgumentsNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1309
-  def visit_arguments_node(node); end
-
-  # Dispatch enter and leave events for ArrayNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1315
-  def visit_array_node(node); end
-
-  # Dispatch enter and leave events for ArrayPatternNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1321
-  def visit_array_pattern_node(node); end
-
-  # Dispatch enter and leave events for AssocNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1327
-  def visit_assoc_node(node); end
-
-  # Dispatch enter and leave events for AssocSplatNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1333
-  def visit_assoc_splat_node(node); end
-
-  # Dispatch enter and leave events for BackReferenceReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1339
-  def visit_back_reference_read_node(node); end
-
-  # Dispatch enter and leave events for BeginNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1345
-  def visit_begin_node(node); end
-
-  # Dispatch enter and leave events for BlockArgumentNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1351
-  def visit_block_argument_node(node); end
-
-  # Dispatch enter and leave events for BlockLocalVariableNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1357
-  def visit_block_local_variable_node(node); end
-
-  # Dispatch enter and leave events for BlockNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1363
-  def visit_block_node(node); end
-
-  # Dispatch enter and leave events for BlockParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1369
-  def visit_block_parameter_node(node); end
-
-  # Dispatch enter and leave events for BlockParametersNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1375
-  def visit_block_parameters_node(node); end
-
-  # Dispatch enter and leave events for BreakNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1381
-  def visit_break_node(node); end
-
-  # Dispatch enter and leave events for CallAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1387
-  def visit_call_and_write_node(node); end
-
-  # Dispatch enter and leave events for CallNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1393
-  def visit_call_node(node); end
-
-  # Dispatch enter and leave events for CallOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1399
-  def visit_call_operator_write_node(node); end
-
-  # Dispatch enter and leave events for CallOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1405
-  def visit_call_or_write_node(node); end
-
-  # Dispatch enter and leave events for CallTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1411
-  def visit_call_target_node(node); end
-
-  # Dispatch enter and leave events for CapturePatternNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1417
-  def visit_capture_pattern_node(node); end
-
-  # Dispatch enter and leave events for CaseMatchNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1423
-  def visit_case_match_node(node); end
-
-  # Dispatch enter and leave events for CaseNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1429
-  def visit_case_node(node); end
-
-  # Dispatch enter and leave events for ClassNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1435
-  def visit_class_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1441
-  def visit_class_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1447
-  def visit_class_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1453
-  def visit_class_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1459
-  def visit_class_variable_read_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1465
-  def visit_class_variable_target_node(node); end
-
-  # Dispatch enter and leave events for ClassVariableWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1471
-  def visit_class_variable_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1477
-  def visit_constant_and_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1483
-  def visit_constant_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1489
-  def visit_constant_or_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1495
-  def visit_constant_path_and_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1501
-  def visit_constant_path_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1507
-  def visit_constant_path_operator_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1513
-  def visit_constant_path_or_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1519
-  def visit_constant_path_target_node(node); end
-
-  # Dispatch enter and leave events for ConstantPathWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1525
-  def visit_constant_path_write_node(node); end
-
-  # Dispatch enter and leave events for ConstantReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1531
-  def visit_constant_read_node(node); end
-
-  # Dispatch enter and leave events for ConstantTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1537
-  def visit_constant_target_node(node); end
-
-  # Dispatch enter and leave events for ConstantWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1543
-  def visit_constant_write_node(node); end
-
-  # Dispatch enter and leave events for DefNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1549
-  def visit_def_node(node); end
-
-  # Dispatch enter and leave events for DefinedNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1555
-  def visit_defined_node(node); end
-
-  # Dispatch enter and leave events for ElseNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1561
-  def visit_else_node(node); end
-
-  # Dispatch enter and leave events for EmbeddedStatementsNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1567
-  def visit_embedded_statements_node(node); end
-
-  # Dispatch enter and leave events for EmbeddedVariableNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1573
-  def visit_embedded_variable_node(node); end
-
-  # Dispatch enter and leave events for EnsureNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1579
-  def visit_ensure_node(node); end
-
-  # Dispatch enter and leave events for FalseNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1585
-  def visit_false_node(node); end
-
-  # Dispatch enter and leave events for FindPatternNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1591
-  def visit_find_pattern_node(node); end
-
-  # Dispatch enter and leave events for FlipFlopNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1597
-  def visit_flip_flop_node(node); end
-
-  # Dispatch enter and leave events for FloatNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1603
-  def visit_float_node(node); end
-
-  # Dispatch enter and leave events for ForNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1609
-  def visit_for_node(node); end
-
-  # Dispatch enter and leave events for ForwardingArgumentsNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1615
-  def visit_forwarding_arguments_node(node); end
-
-  # Dispatch enter and leave events for ForwardingParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1621
-  def visit_forwarding_parameter_node(node); end
-
-  # Dispatch enter and leave events for ForwardingSuperNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1627
-  def visit_forwarding_super_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1633
-  def visit_global_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1639
-  def visit_global_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1645
-  def visit_global_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1651
-  def visit_global_variable_read_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1657
-  def visit_global_variable_target_node(node); end
-
-  # Dispatch enter and leave events for GlobalVariableWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1663
-  def visit_global_variable_write_node(node); end
-
-  # Dispatch enter and leave events for HashNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1669
-  def visit_hash_node(node); end
-
-  # Dispatch enter and leave events for HashPatternNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1675
-  def visit_hash_pattern_node(node); end
-
-  # Dispatch enter and leave events for IfNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1681
-  def visit_if_node(node); end
-
-  # Dispatch enter and leave events for ImaginaryNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1687
-  def visit_imaginary_node(node); end
-
-  # Dispatch enter and leave events for ImplicitNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1693
-  def visit_implicit_node(node); end
-
-  # Dispatch enter and leave events for ImplicitRestNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1699
-  def visit_implicit_rest_node(node); end
-
-  # Dispatch enter and leave events for InNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1705
-  def visit_in_node(node); end
-
-  # Dispatch enter and leave events for IndexAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1711
-  def visit_index_and_write_node(node); end
-
-  # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1717
-  def visit_index_operator_write_node(node); end
-
-  # Dispatch enter and leave events for IndexOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1723
-  def visit_index_or_write_node(node); end
-
-  # Dispatch enter and leave events for IndexTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1729
-  def visit_index_target_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1735
-  def visit_instance_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1741
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1747
-  def visit_instance_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1753
-  def visit_instance_variable_read_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1759
-  def visit_instance_variable_target_node(node); end
-
-  # Dispatch enter and leave events for InstanceVariableWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1765
-  def visit_instance_variable_write_node(node); end
-
-  # Dispatch enter and leave events for IntegerNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1771
-  def visit_integer_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1777
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1783
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedStringNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1789
-  def visit_interpolated_string_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedSymbolNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1795
-  def visit_interpolated_symbol_node(node); end
-
-  # Dispatch enter and leave events for InterpolatedXStringNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1801
-  def visit_interpolated_x_string_node(node); end
-
-  # Dispatch enter and leave events for ItLocalVariableReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1807
-  def visit_it_local_variable_read_node(node); end
-
-  # Dispatch enter and leave events for ItParametersNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1813
-  def visit_it_parameters_node(node); end
-
-  # Dispatch enter and leave events for KeywordHashNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1819
-  def visit_keyword_hash_node(node); end
-
-  # Dispatch enter and leave events for KeywordRestParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1825
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Dispatch enter and leave events for LambdaNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1831
-  def visit_lambda_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1837
-  def visit_local_variable_and_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1843
-  def visit_local_variable_operator_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1849
-  def visit_local_variable_or_write_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1855
-  def visit_local_variable_read_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1861
-  def visit_local_variable_target_node(node); end
-
-  # Dispatch enter and leave events for LocalVariableWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1867
-  def visit_local_variable_write_node(node); end
-
-  # Dispatch enter and leave events for MatchLastLineNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1873
-  def visit_match_last_line_node(node); end
-
-  # Dispatch enter and leave events for MatchPredicateNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1879
-  def visit_match_predicate_node(node); end
-
-  # Dispatch enter and leave events for MatchRequiredNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1885
-  def visit_match_required_node(node); end
-
-  # Dispatch enter and leave events for MatchWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1891
-  def visit_match_write_node(node); end
-
-  # Dispatch enter and leave events for MissingNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1897
-  def visit_missing_node(node); end
-
-  # Dispatch enter and leave events for ModuleNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1903
-  def visit_module_node(node); end
-
-  # Dispatch enter and leave events for MultiTargetNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1909
-  def visit_multi_target_node(node); end
-
-  # Dispatch enter and leave events for MultiWriteNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1915
-  def visit_multi_write_node(node); end
-
-  # Dispatch enter and leave events for NextNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1921
-  def visit_next_node(node); end
-
-  # Dispatch enter and leave events for NilNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1927
-  def visit_nil_node(node); end
-
-  # Dispatch enter and leave events for NoKeywordsParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1933
-  def visit_no_keywords_parameter_node(node); end
-
-  # Dispatch enter and leave events for NumberedParametersNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1939
-  def visit_numbered_parameters_node(node); end
-
-  # Dispatch enter and leave events for NumberedReferenceReadNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1945
-  def visit_numbered_reference_read_node(node); end
-
-  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1951
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Dispatch enter and leave events for OptionalParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1957
-  def visit_optional_parameter_node(node); end
-
-  # Dispatch enter and leave events for OrNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1963
-  def visit_or_node(node); end
-
-  # Dispatch enter and leave events for ParametersNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1969
-  def visit_parameters_node(node); end
-
-  # Dispatch enter and leave events for ParenthesesNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1975
-  def visit_parentheses_node(node); end
-
-  # Dispatch enter and leave events for PinnedExpressionNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1981
-  def visit_pinned_expression_node(node); end
-
-  # Dispatch enter and leave events for PinnedVariableNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1987
-  def visit_pinned_variable_node(node); end
-
-  # Dispatch enter and leave events for PostExecutionNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1993
-  def visit_post_execution_node(node); end
-
-  # Dispatch enter and leave events for PreExecutionNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#1999
-  def visit_pre_execution_node(node); end
-
-  # Dispatch enter and leave events for ProgramNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2005
-  def visit_program_node(node); end
-
-  # Dispatch enter and leave events for RangeNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2011
-  def visit_range_node(node); end
-
-  # Dispatch enter and leave events for RationalNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2017
-  def visit_rational_node(node); end
-
-  # Dispatch enter and leave events for RedoNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2023
-  def visit_redo_node(node); end
-
-  # Dispatch enter and leave events for RegularExpressionNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2029
-  def visit_regular_expression_node(node); end
-
-  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2035
-  def visit_required_keyword_parameter_node(node); end
-
-  # Dispatch enter and leave events for RequiredParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2041
-  def visit_required_parameter_node(node); end
-
-  # Dispatch enter and leave events for RescueModifierNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2047
-  def visit_rescue_modifier_node(node); end
-
-  # Dispatch enter and leave events for RescueNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2053
-  def visit_rescue_node(node); end
-
-  # Dispatch enter and leave events for RestParameterNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2059
-  def visit_rest_parameter_node(node); end
-
-  # Dispatch enter and leave events for RetryNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2065
-  def visit_retry_node(node); end
-
-  # Dispatch enter and leave events for ReturnNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2071
-  def visit_return_node(node); end
-
-  # Dispatch enter and leave events for SelfNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2077
-  def visit_self_node(node); end
-
-  # Dispatch enter and leave events for ShareableConstantNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2083
-  def visit_shareable_constant_node(node); end
-
-  # Dispatch enter and leave events for SingletonClassNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2089
-  def visit_singleton_class_node(node); end
-
-  # Dispatch enter and leave events for SourceEncodingNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2095
-  def visit_source_encoding_node(node); end
-
-  # Dispatch enter and leave events for SourceFileNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2101
-  def visit_source_file_node(node); end
-
-  # Dispatch enter and leave events for SourceLineNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2107
-  def visit_source_line_node(node); end
-
-  # Dispatch enter and leave events for SplatNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2113
-  def visit_splat_node(node); end
-
-  # Dispatch enter and leave events for StatementsNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2119
-  def visit_statements_node(node); end
-
-  # Dispatch enter and leave events for StringNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2125
-  def visit_string_node(node); end
-
-  # Dispatch enter and leave events for SuperNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2131
-  def visit_super_node(node); end
-
-  # Dispatch enter and leave events for SymbolNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2137
-  def visit_symbol_node(node); end
-
-  # Dispatch enter and leave events for TrueNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2143
-  def visit_true_node(node); end
-
-  # Dispatch enter and leave events for UndefNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2149
-  def visit_undef_node(node); end
-
-  # Dispatch enter and leave events for UnlessNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2155
-  def visit_unless_node(node); end
-
-  # Dispatch enter and leave events for UntilNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2161
-  def visit_until_node(node); end
-
-  # Dispatch enter and leave events for WhenNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2167
-  def visit_when_node(node); end
-
-  # Dispatch enter and leave events for WhileNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2173
-  def visit_while_node(node); end
-
-  # Dispatch enter and leave events for XStringNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2179
-  def visit_x_string_node(node); end
-
-  # Dispatch enter and leave events for YieldNode nodes.
-  #
-  # source://prism//lib/prism/dispatcher.rb#2185
-  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//lib/prism/dot_visitor.rb#14
-class Prism::DotVisitor < ::Prism::Visitor
-  # Initialize a new dot visitor.
-  #
-  # @return [DotVisitor] a new instance of DotVisitor
-  #
-  # source://prism//lib/prism/dot_visitor.rb#106
-  def initialize; end
-
-  # The digraph that is being built.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#103
-  def digraph; end
-
-  # Convert this visitor into a graphviz dot graph string.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#111
-  def to_dot; end
-
-  # Visit a AliasGlobalVariableNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#116
-  def visit_alias_global_variable_node(node); end
-
-  # Visit a AliasMethodNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#141
-  def visit_alias_method_node(node); end
-
-  # Visit a AlternationPatternNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#166
-  def visit_alternation_pattern_node(node); end
-
-  # Visit a AndNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#191
-  def visit_and_node(node); end
-
-  # Visit a ArgumentsNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#216
-  def visit_arguments_node(node); end
-
-  # Visit a ArrayNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#246
-  def visit_array_node(node); end
-
-  # Visit a ArrayPatternNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#286
-  def visit_array_pattern_node(node); end
-
-  # Visit a AssocNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#348
-  def visit_assoc_node(node); end
-
-  # Visit a AssocSplatNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#375
-  def visit_assoc_splat_node(node); end
-
-  # Visit a BackReferenceReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#398
-  def visit_back_reference_read_node(node); end
-
-  # Visit a BeginNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#415
-  def visit_begin_node(node); end
-
-  # Visit a BlockArgumentNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#463
-  def visit_block_argument_node(node); end
-
-  # Visit a BlockLocalVariableNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#486
-  def visit_block_local_variable_node(node); end
-
-  # Visit a BlockNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#506
-  def visit_block_node(node); end
-
-  # Visit a BlockParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#541
-  def visit_block_parameter_node(node); end
-
-  # Visit a BlockParametersNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#569
-  def visit_block_parameters_node(node); end
-
-  # Visit a BreakNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#612
-  def visit_break_node(node); end
-
-  # Visit a CallAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#635
-  def visit_call_and_write_node(node); end
-
-  # Visit a CallNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#681
-  def visit_call_node(node); end
-
-  # Visit a CallOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#739
-  def visit_call_operator_write_node(node); end
-
-  # Visit a CallOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#788
-  def visit_call_or_write_node(node); end
-
-  # Visit a CallTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#834
-  def visit_call_target_node(node); end
-
-  # Visit a CapturePatternNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#864
-  def visit_capture_pattern_node(node); end
-
-  # Visit a CaseMatchNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#889
-  def visit_case_match_node(node); end
-
-  # Visit a CaseNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#934
-  def visit_case_node(node); end
-
-  # Visit a ClassNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#979
-  def visit_class_node(node); end
-
-  # Visit a ClassVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1026
-  def visit_class_variable_and_write_node(node); end
-
-  # Visit a ClassVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1053
-  def visit_class_variable_operator_write_node(node); end
-
-  # Visit a ClassVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1083
-  def visit_class_variable_or_write_node(node); end
-
-  # Visit a ClassVariableReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1110
-  def visit_class_variable_read_node(node); end
-
-  # Visit a ClassVariableTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1127
-  def visit_class_variable_target_node(node); end
-
-  # Visit a ClassVariableWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1144
-  def visit_class_variable_write_node(node); end
-
-  # Visit a ConstantAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1171
-  def visit_constant_and_write_node(node); end
-
-  # Visit a ConstantOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1198
-  def visit_constant_operator_write_node(node); end
-
-  # Visit a ConstantOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1228
-  def visit_constant_or_write_node(node); end
-
-  # Visit a ConstantPathAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1255
-  def visit_constant_path_and_write_node(node); end
-
-  # Visit a ConstantPathNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1280
-  def visit_constant_path_node(node); end
-
-  # Visit a ConstantPathOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1309
-  def visit_constant_path_operator_write_node(node); end
-
-  # Visit a ConstantPathOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1337
-  def visit_constant_path_or_write_node(node); end
-
-  # Visit a ConstantPathTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1362
-  def visit_constant_path_target_node(node); end
-
-  # Visit a ConstantPathWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1391
-  def visit_constant_path_write_node(node); end
-
-  # Visit a ConstantReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1416
-  def visit_constant_read_node(node); end
-
-  # Visit a ConstantTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1433
-  def visit_constant_target_node(node); end
-
-  # Visit a ConstantWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1450
-  def visit_constant_write_node(node); end
-
-  # Visit a DefNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1477
-  def visit_def_node(node); end
-
-  # Visit a DefinedNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1546
-  def visit_defined_node(node); end
-
-  # Visit a ElseNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1577
-  def visit_else_node(node); end
-
-  # Visit a EmbeddedStatementsNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1605
-  def visit_embedded_statements_node(node); end
-
-  # Visit a EmbeddedVariableNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1631
-  def visit_embedded_variable_node(node); end
-
-  # Visit a EnsureNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1652
-  def visit_ensure_node(node); end
-
-  # Visit a FalseNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1678
-  def visit_false_node(node); end
-
-  # Visit a FindPatternNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1692
-  def visit_find_pattern_node(node); end
-
-  # Visit a FlipFlopNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1743
-  def visit_flip_flop_node(node); end
-
-  # Visit a FloatNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1775
-  def visit_float_node(node); end
-
-  # Visit a ForNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1792
-  def visit_for_node(node); end
-
-  # Visit a ForwardingArgumentsNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1834
-  def visit_forwarding_arguments_node(node); end
-
-  # Visit a ForwardingParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1848
-  def visit_forwarding_parameter_node(node); end
-
-  # Visit a ForwardingSuperNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1862
-  def visit_forwarding_super_node(node); end
-
-  # Visit a GlobalVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1882
-  def visit_global_variable_and_write_node(node); end
-
-  # Visit a GlobalVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1909
-  def visit_global_variable_operator_write_node(node); end
-
-  # Visit a GlobalVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1939
-  def visit_global_variable_or_write_node(node); end
-
-  # Visit a GlobalVariableReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1966
-  def visit_global_variable_read_node(node); end
-
-  # Visit a GlobalVariableTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#1983
-  def visit_global_variable_target_node(node); end
-
-  # Visit a GlobalVariableWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2000
-  def visit_global_variable_write_node(node); end
-
-  # Visit a HashNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2027
-  def visit_hash_node(node); end
-
-  # Visit a HashPatternNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2060
-  def visit_hash_pattern_node(node); end
-
-  # Visit a IfNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2109
-  def visit_if_node(node); end
-
-  # Visit a ImaginaryNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2154
-  def visit_imaginary_node(node); end
-
-  # Visit a ImplicitNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2172
-  def visit_implicit_node(node); end
-
-  # Visit a ImplicitRestNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2190
-  def visit_implicit_rest_node(node); end
-
-  # Visit a InNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2204
-  def visit_in_node(node); end
-
-  # Visit a IndexAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2236
-  def visit_index_and_write_node(node); end
-
-  # Visit a IndexOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2289
-  def visit_index_operator_write_node(node); end
-
-  # Visit a IndexOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2345
-  def visit_index_or_write_node(node); end
-
-  # Visit a IndexTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2398
-  def visit_index_target_node(node); end
-
-  # Visit a InstanceVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2437
-  def visit_instance_variable_and_write_node(node); end
-
-  # Visit a InstanceVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2464
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Visit a InstanceVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2494
-  def visit_instance_variable_or_write_node(node); end
-
-  # Visit a InstanceVariableReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2521
-  def visit_instance_variable_read_node(node); end
-
-  # Visit a InstanceVariableTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2538
-  def visit_instance_variable_target_node(node); end
-
-  # Visit a InstanceVariableWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2555
-  def visit_instance_variable_write_node(node); end
-
-  # Visit a IntegerNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2582
-  def visit_integer_node(node); end
-
-  # Visit a InterpolatedMatchLastLineNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2602
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Visit a InterpolatedRegularExpressionNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2638
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Visit a InterpolatedStringNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2674
-  def visit_interpolated_string_node(node); end
-
-  # Visit a InterpolatedSymbolNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2714
-  def visit_interpolated_symbol_node(node); end
-
-  # Visit a InterpolatedXStringNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2751
-  def visit_interpolated_x_string_node(node); end
-
-  # Visit a ItLocalVariableReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2784
-  def visit_it_local_variable_read_node(node); end
-
-  # Visit a ItParametersNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2798
-  def visit_it_parameters_node(node); end
-
-  # Visit a KeywordHashNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2812
-  def visit_keyword_hash_node(node); end
-
-  # Visit a KeywordRestParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2842
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Visit a LambdaNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2870
-  def visit_lambda_node(node); end
-
-  # Visit a LocalVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2908
-  def visit_local_variable_and_write_node(node); end
-
-  # Visit a LocalVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2938
-  def visit_local_variable_operator_write_node(node); end
-
-  # Visit a LocalVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#2971
-  def visit_local_variable_or_write_node(node); end
-
-  # Visit a LocalVariableReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3001
-  def visit_local_variable_read_node(node); end
-
-  # Visit a LocalVariableTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3021
-  def visit_local_variable_target_node(node); end
-
-  # Visit a LocalVariableWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3041
-  def visit_local_variable_write_node(node); end
-
-  # Visit a MatchLastLineNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3071
-  def visit_match_last_line_node(node); end
-
-  # Visit a MatchPredicateNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3100
-  def visit_match_predicate_node(node); end
-
-  # Visit a MatchRequiredNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3125
-  def visit_match_required_node(node); end
-
-  # Visit a MatchWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3150
-  def visit_match_write_node(node); end
-
-  # Visit a MissingNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3181
-  def visit_missing_node(node); end
-
-  # Visit a ModuleNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3195
-  def visit_module_node(node); end
-
-  # Visit a MultiTargetNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3231
-  def visit_multi_target_node(node); end
-
-  # Visit a MultiWriteNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3287
-  def visit_multi_write_node(node); end
-
-  # Visit a NextNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3350
-  def visit_next_node(node); end
-
-  # Visit a NilNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3373
-  def visit_nil_node(node); end
-
-  # Visit a NoKeywordsParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3387
-  def visit_no_keywords_parameter_node(node); end
-
-  # Visit a NumberedParametersNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3407
-  def visit_numbered_parameters_node(node); end
-
-  # Visit a NumberedReferenceReadNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3424
-  def visit_numbered_reference_read_node(node); end
-
-  # Visit a OptionalKeywordParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3441
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Visit a OptionalParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3468
-  def visit_optional_parameter_node(node); end
-
-  # Visit a OrNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3498
-  def visit_or_node(node); end
-
-  # Visit a ParametersNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3523
-  def visit_parameters_node(node); end
-
-  # Visit a ParenthesesNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3607
-  def visit_parentheses_node(node); end
-
-  # Visit a PinnedExpressionNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3633
-  def visit_pinned_expression_node(node); end
-
-  # Visit a PinnedVariableNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3660
-  def visit_pinned_variable_node(node); end
-
-  # Visit a PostExecutionNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3681
-  def visit_post_execution_node(node); end
-
-  # Visit a PreExecutionNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3710
-  def visit_pre_execution_node(node); end
-
-  # Visit a ProgramNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3739
-  def visit_program_node(node); end
-
-  # Visit a RangeNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3760
-  def visit_range_node(node); end
-
-  # Visit a RationalNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3792
-  def visit_rational_node(node); end
-
-  # Visit a RedoNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3815
-  def visit_redo_node(node); end
-
-  # Visit a RegularExpressionNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3829
-  def visit_regular_expression_node(node); end
-
-  # Visit a RequiredKeywordParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3858
-  def visit_required_keyword_parameter_node(node); end
-
-  # Visit a RequiredParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3881
-  def visit_required_parameter_node(node); end
-
-  # Visit a RescueModifierNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3901
-  def visit_rescue_modifier_node(node); end
-
-  # Visit a RescueNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3926
-  def visit_rescue_node(node); end
-
-  # Visit a RestParameterNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#3979
-  def visit_rest_parameter_node(node); end
-
-  # Visit a RetryNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4007
-  def visit_retry_node(node); end
-
-  # Visit a ReturnNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4021
-  def visit_return_node(node); end
-
-  # Visit a SelfNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4047
-  def visit_self_node(node); end
-
-  # Visit a ShareableConstantNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4061
-  def visit_shareable_constant_node(node); end
-
-  # Visit a SingletonClassNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4082
-  def visit_singleton_class_node(node); end
-
-  # Visit a SourceEncodingNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4118
-  def visit_source_encoding_node(node); end
-
-  # Visit a SourceFileNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4132
-  def visit_source_file_node(node); end
-
-  # Visit a SourceLineNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4152
-  def visit_source_line_node(node); end
-
-  # Visit a SplatNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4166
-  def visit_splat_node(node); end
-
-  # Visit a StatementsNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4189
-  def visit_statements_node(node); end
-
-  # Visit a StringNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4216
-  def visit_string_node(node); end
-
-  # Visit a SuperNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4249
-  def visit_super_node(node); end
-
-  # Visit a SymbolNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4288
-  def visit_symbol_node(node); end
-
-  # Visit a TrueNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4323
-  def visit_true_node(node); end
-
-  # Visit a UndefNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4337
-  def visit_undef_node(node); end
-
-  # Visit a UnlessNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4367
-  def visit_unless_node(node); end
-
-  # Visit a UntilNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4410
-  def visit_until_node(node); end
-
-  # Visit a WhenNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4445
-  def visit_when_node(node); end
-
-  # Visit a WhileNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4486
-  def visit_while_node(node); end
-
-  # Visit a XStringNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4521
-  def visit_x_string_node(node); end
-
-  # Visit a YieldNode node.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4550
-  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//lib/prism/dot_visitor.rb#4596
-  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//lib/prism/dot_visitor.rb#4605
-  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//lib/prism/dot_visitor.rb#4613
-  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//lib/prism/dot_visitor.rb#4624
-  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//lib/prism/dot_visitor.rb#4633
-  def integer_base_flags_inspect(node); end
-
-  # Inspect a node that has interpolated_string_node_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4644
-  def interpolated_string_node_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//lib/prism/dot_visitor.rb#4653
-  def keyword_hash_node_flags_inspect(node); end
-
-  # Inspect a location to display the start and end line and column numbers.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4590
-  def location_inspect(location); end
-
-  # Inspect a node that has loop_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4661
-  def loop_flags_inspect(node); end
-
-  # Generate a unique node ID for a node throughout the digraph.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4585
-  def node_id(node); end
-
-  # Inspect a node that has parameter_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4669
-  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//lib/prism/dot_visitor.rb#4677
-  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//lib/prism/dot_visitor.rb#4685
-  def regular_expression_flags_inspect(node); end
-
-  # Inspect a node that has return_node_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4703
-  def return_node_flags_inspect(node); end
-
-  # Inspect a node that has shareable_constant_node_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4711
-  def shareable_constant_node_flags_inspect(node); end
-
-  # Inspect a node that has string_flags flags to display the flags as a
-  # comma-separated list.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#4721
-  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//lib/prism/dot_visitor.rb#4732
-  def symbol_flags_inspect(node); end
-end
-
-# source://prism//lib/prism/dot_visitor.rb#59
-class Prism::DotVisitor::Digraph
-  # @return [Digraph] a new instance of Digraph
-  #
-  # source://prism//lib/prism/dot_visitor.rb#62
-  def initialize; end
-
-  # source://prism//lib/prism/dot_visitor.rb#76
-  def edge(value); end
-
-  # Returns the value of attribute edges.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#60
-  def edges; end
-
-  # source://prism//lib/prism/dot_visitor.rb#68
-  def node(value); end
-
-  # Returns the value of attribute nodes.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#60
-  def nodes; end
-
-  # source://prism//lib/prism/dot_visitor.rb#80
-  def to_dot; end
-
-  # source://prism//lib/prism/dot_visitor.rb#72
-  def waypoint(value); end
-
-  # Returns the value of attribute waypoints.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#60
-  def waypoints; end
-end
-
-# source://prism//lib/prism/dot_visitor.rb#15
-class Prism::DotVisitor::Field
-  # @return [Field] a new instance of Field
-  #
-  # source://prism//lib/prism/dot_visitor.rb#18
-  def initialize(name, value, port); end
-
-  # Returns the value of attribute name.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#16
-  def name; end
-
-  # Returns the value of attribute port.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#16
-  def port; end
-
-  # source://prism//lib/prism/dot_visitor.rb#24
-  def to_dot; end
-
-  # Returns the value of attribute value.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#16
-  def value; end
-end
-
-# source://prism//lib/prism/dot_visitor.rb#33
-class Prism::DotVisitor::Table
-  # @return [Table] a new instance of Table
-  #
-  # source://prism//lib/prism/dot_visitor.rb#36
-  def initialize(name); end
-
-  # source://prism//lib/prism/dot_visitor.rb#41
-  def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
-
-  # Returns the value of attribute fields.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#34
-  def fields; end
-
-  # Returns the value of attribute name.
-  #
-  # source://prism//lib/prism/dot_visitor.rb#34
-  def name; end
-
-  # source://prism//lib/prism/dot_visitor.rb#45
-  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//lib/prism/node.rb#6173
-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//lib/prism/node.rb#6175
-  sig do
-    params(
-      source: Prism::Source,
-      else_keyword_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, else_keyword_loc, statements, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6286
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6184
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6189
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6201
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6194
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?, ?location: Location) -> ElseNode
-  #
-  # source://prism//lib/prism/node.rb#6206
-  sig do
-    params(
-      else_keyword_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::ElseNode)
-  end
-  def copy(else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6189
-  sig { override.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//lib/prism/node.rb#6214
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def else_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6242
-  sig { returns(String) }
-  def else_keyword; end
-
-  # attr_reader else_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6219
-  sig { returns(Prism::Location) }
-  def else_keyword_loc; end
-
-  # def end_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#6247
-  sig { returns(T.nilable(String)) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#6229
-  sig { returns(T.nilable(Prism::Location)) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6252
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#6226
-  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//lib/prism/node.rb#6270
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6280
-    def type; end
-  end
-end
-
-# EmbDocComment objects correspond to comments that are surrounded by =begin
-# and =end.
-#
-# source://prism//lib/prism/parse_result.rb#403
-class Prism::EmbDocComment < ::Prism::Comment
-  # Returns a string representation of this comment.
-  #
-  # source://prism//lib/prism/parse_result.rb#410
-  sig { returns(String) }
-  def inspect; end
-
-  # This can only be true for inline comments.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/parse_result.rb#405
-  sig { override.returns(T::Boolean) }
-  def trailing?; end
-end
-
-# Represents an interpolated set of statements.
-#
-#     "foo #{bar}"
-#          ^^^^^^
-#
-# source://prism//lib/prism/node.rb#6298
-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//lib/prism/node.rb#6300
-  sig do
-    params(
-      source: Prism::Source,
-      opening_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, opening_loc, statements, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6405
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6309
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6314
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6366
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6354
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6326
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6319
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location, ?location: Location) -> EmbeddedStatementsNode
-  #
-  # source://prism//lib/prism/node.rb#6331
-  sig do
-    params(
-      opening_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::EmbeddedStatementsNode)
-  end
-  def copy(opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6314
-  sig { override.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//lib/prism/node.rb#6339
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6371
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6361
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6344
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#6351
-  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//lib/prism/node.rb#6389
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6399
-    def type; end
-  end
-end
-
-# Represents an interpolated variable.
-#
-#     "foo #@bar"
-#          ^^^^^
-#
-# source://prism//lib/prism/node.rb#6417
-class Prism::EmbeddedVariableNode < ::Prism::Node
-  # def initialize: (Location operator_loc, Prism::node variable, Location location) -> void
-  #
-  # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
-  #
-  # source://prism//lib/prism/node.rb#6419
-  sig do
-    params(
-      source: Prism::Source,
-      operator_loc: Prism::Location,
-      variable: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, operator_loc, variable, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6509
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6427
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6432
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6442
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6437
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?operator_loc: Location, ?variable: Prism::node, ?location: Location) -> EmbeddedVariableNode
-  #
-  # source://prism//lib/prism/node.rb#6447
-  sig do
-    params(
-      operator_loc: Prism::Location,
-      variable: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::EmbeddedVariableNode)
-  end
-  def copy(operator_loc: T.unsafe(nil), variable: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6432
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, variable: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#6455
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6475
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6470
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6460
-  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//lib/prism/node.rb#6493
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader variable: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#6467
-  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//lib/prism/node.rb#6503
-    def type; end
-  end
-end
-
-# Flags for nodes that have unescaped content.
-#
-# source://prism//lib/prism/node.rb#19157
-module Prism::EncodingFlags; end
-
-# internal bytes forced the encoding to binary
-#
-# source://prism//lib/prism/node.rb#19162
-Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to UTF-8
-#
-# source://prism//lib/prism/node.rb#19159
-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//lib/prism/node.rb#6524
-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//lib/prism/node.rb#6526
-  sig do
-    params(
-      source: Prism::Source,
-      ensure_keyword_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, ensure_keyword_loc, statements, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6631
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6535
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6540
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6552
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6545
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location, ?location: Location) -> EnsureNode
-  #
-  # source://prism//lib/prism/node.rb#6557
-  sig do
-    params(
-      ensure_keyword_loc: Prism::Location,
-      statements: T.nilable(Prism::StatementsNode),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::EnsureNode)
-  end
-  def copy(ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6540
-  sig { override.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//lib/prism/node.rb#6565
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6592
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6580
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  # def ensure_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6587
-  sig { returns(String) }
-  def ensure_keyword; end
-
-  # attr_reader ensure_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6570
-  sig { returns(Prism::Location) }
-  def ensure_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6597
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#6577
-  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//lib/prism/node.rb#6615
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6625
-    def type; end
-  end
-end
-
-# Represents the use of the literal `false` keyword.
-#
-#     false
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#6643
-class Prism::FalseNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [FalseNode] a new instance of FalseNode
-  #
-  # source://prism//lib/prism/node.rb#6645
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6718
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6651
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6656
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6666
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6661
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> FalseNode
-  #
-  # source://prism//lib/prism/node.rb#6671
-  sig { params(location: Prism::Location).returns(Prism::FalseNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6656
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#6679
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6684
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#6702
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6712
-    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//lib/prism/node.rb#6733
-class Prism::FindPatternNode < ::Prism::Node
-  # def initialize: (Prism::node? constant, Prism::node left, Array[Prism::node] requireds, Prism::node right, Location? opening_loc, Location? closing_loc, Location location) -> void
-  #
-  # @return [FindPatternNode] a new instance of FindPatternNode
-  #
-  # source://prism//lib/prism/node.rb#6735
-  sig do
-    params(
-      source: Prism::Source,
-      constant: T.nilable(Prism::Node),
-      left: Prism::Node,
-      requireds: T::Array[Prism::Node],
-      right: Prism::Node,
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, constant, left, requireds, right, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6867
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6747
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6752
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#6828
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#6810
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6767
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6757
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader constant: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#6785
-  sig { returns(T.nilable(Prism::Node)) }
-  def constant; end
-
-  # def copy: (?constant: Prism::node?, ?left: Prism::node, ?requireds: Array[Prism::node], ?right: Prism::node, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> FindPatternNode
-  #
-  # source://prism//lib/prism/node.rb#6772
-  sig do
-    params(
-      constant: T.nilable(Prism::Node),
-      left: Prism::Node,
-      requireds: T::Array[Prism::Node],
-      right: Prism::Node,
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::FindPatternNode)
-  end
-  def copy(constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6752
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, left: Prism::node, requireds: Array[Prism::node], right: Prism::node, opening_loc: Location?, closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#6780
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6833
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader left: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#6788
-  sig { returns(Prism::Node) }
-  def left; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#6823
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#6797
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader requireds: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#6791
-  sig { returns(T::Array[Prism::Node]) }
-  def requireds; end
-
-  # attr_reader right: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#6794
-  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//lib/prism/node.rb#6851
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#6861
-    def type; end
-  end
-end
-
-# Represents the use of the `..` or `...` operators to create flip flops.
-#
-#     baz if foo .. bar
-#            ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#6883
-class Prism::FlipFlopNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
-  #
-  # @return [FlipFlopNode] a new instance of FlipFlopNode
-  #
-  # source://prism//lib/prism/node.rb#6885
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      left: T.nilable(Prism::Node),
-      right: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, left, right, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#6992
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#6895
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6900
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#6913
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#6905
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> FlipFlopNode
-  #
-  # source://prism//lib/prism/node.rb#6918
-  sig do
-    params(
-      flags: Integer,
-      left: T.nilable(Prism::Node),
-      right: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::FlipFlopNode)
-  end
-  def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#6900
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#6926
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def exclude_end?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#6948
-  sig { returns(T::Boolean) }
-  def exclude_end?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#6958
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader left: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#6935
-  sig { returns(T.nilable(Prism::Node)) }
-  def left; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#6953
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#6941
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader right: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#6938
-  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//lib/prism/node.rb#6976
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#6931
-  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//lib/prism/node.rb#6986
-    def type; end
-  end
-end
-
-# Represents a floating point number literal.
-#
-#     1.0
-#     ^^^
-#
-# source://prism//lib/prism/node.rb#7005
-class Prism::FloatNode < ::Prism::Node
-  # def initialize: (Float value, Location location) -> void
-  #
-  # @return [FloatNode] a new instance of FloatNode
-  #
-  # source://prism//lib/prism/node.rb#7007
-  sig { params(source: Prism::Source, value: Float, location: Prism::Location).void }
-  def initialize(source, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7084
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7014
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7019
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7029
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7024
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Float, ?location: Location) -> FloatNode
-  #
-  # source://prism//lib/prism/node.rb#7034
-  sig { params(value: Float, location: Prism::Location).returns(Prism::FloatNode) }
-  def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7019
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Float, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7042
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7050
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#7068
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value of the floating point number as a Float.
-  #
-  # source://prism//lib/prism/node.rb#7047
-  sig { returns(Float) }
-  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//lib/prism/node.rb#7078
-    def type; end
-  end
-end
-
-# Represents the use of the `for` keyword.
-#
-#     for i in a end
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#7094
-class Prism::ForNode < ::Prism::Node
-  # def initialize: (Prism::node index, Prism::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//lib/prism/node.rb#7096
-  sig do
-    params(
-      source: Prism::Source,
-      index: Prism::Node,
-      collection: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      for_keyword_loc: Prism::Location,
-      in_keyword_loc: Prism::Location,
-      do_keyword_loc: T.nilable(Prism::Location),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7266
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7109
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7114
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # The collection to iterate over.
-  #
-  #     for i in a end
-  #              ^
-  #
-  # source://prism//lib/prism/node.rb#7155
-  sig { returns(Prism::Node) }
-  def collection; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7128
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7119
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?index: Prism::node, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location, ?location: Location) -> ForNode
-  #
-  # source://prism//lib/prism/node.rb#7133
-  sig do
-    params(
-      index: Prism::Node,
-      collection: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      for_keyword_loc: Prism::Location,
-      in_keyword_loc: Prism::Location,
-      do_keyword_loc: T.nilable(Prism::Location),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ForNode)
-  end
-  def copy(index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7114
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { index: Prism::node, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7141
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def do_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#7222
-  sig { returns(T.nilable(String)) }
-  def do_keyword; end
-
-  # The location of the `do` keyword, if present.
-  #
-  #     for i in a do end
-  #                ^^
-  #
-  # source://prism//lib/prism/node.rb#7189
-  sig { returns(T.nilable(Prism::Location)) }
-  def do_keyword_loc; end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#7227
-  sig { returns(String) }
-  def end_keyword; end
-
-  # The location of the `end` keyword.
-  #
-  #     for i in a end
-  #                ^^^
-  #
-  # source://prism//lib/prism/node.rb#7205
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def for_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#7212
-  sig { returns(String) }
-  def for_keyword; end
-
-  # The location of the `for` keyword.
-  #
-  #     for i in a end
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#7169
-  sig { returns(Prism::Location) }
-  def for_keyword_loc; end
-
-  # def in_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#7217
-  sig { returns(String) }
-  def in_keyword; end
-
-  # The location of the `in` keyword.
-  #
-  #     for i in a end
-  #           ^^
-  #
-  # source://prism//lib/prism/node.rb#7179
-  sig { returns(Prism::Location) }
-  def in_keyword_loc; end
-
-  # The index expression for `for` loops.
-  #
-  #     for i in a end
-  #         ^
-  #
-  # source://prism//lib/prism/node.rb#7149
-  sig { returns(Prism::Node) }
-  def index; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7232
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Represents the body of statements to execute for each iteration of the loop.
-  #
-  #     for i in a
-  #       foo(i)
-  #       ^^^^^^
-  #     end
-  #
-  # source://prism//lib/prism/node.rb#7163
-  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//lib/prism/node.rb#7250
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#7260
-    def type; end
-  end
-end
-
-# Represents forwarding all arguments to this method to another method.
-#
-#     def foo(...)
-#       bar(...)
-#           ^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#7284
-class Prism::ForwardingArgumentsNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
-  #
-  # source://prism//lib/prism/node.rb#7286
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7359
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7292
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7297
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7307
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7302
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> ForwardingArgumentsNode
-  #
-  # source://prism//lib/prism/node.rb#7312
-  sig { params(location: Prism::Location).returns(Prism::ForwardingArgumentsNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7297
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7320
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7325
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#7343
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#7353
-    def type; end
-  end
-end
-
-# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
-#
-#     def foo(...)
-#             ^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#7369
-class Prism::ForwardingParameterNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
-  #
-  # source://prism//lib/prism/node.rb#7371
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7444
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7377
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7382
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7392
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7387
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> ForwardingParameterNode
-  #
-  # source://prism//lib/prism/node.rb#7397
-  sig { params(location: Prism::Location).returns(Prism::ForwardingParameterNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7382
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7405
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7410
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#7428
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#7438
-    def type; end
-  end
-end
-
-# Represents the use of the `super` keyword without parentheses or arguments.
-#
-#     super
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#7453
-class Prism::ForwardingSuperNode < ::Prism::Node
-  # def initialize: (BlockNode? block, Location location) -> void
-  #
-  # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
-  #
-  # source://prism//lib/prism/node.rb#7455
-  sig { params(source: Prism::Source, block: T.nilable(Prism::BlockNode), location: Prism::Location).void }
-  def initialize(source, block, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7534
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7462
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader block: BlockNode?
-  #
-  # source://prism//lib/prism/node.rb#7497
-  sig { returns(T.nilable(Prism::BlockNode)) }
-  def block; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7467
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7479
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7472
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?block: BlockNode?, ?location: Location) -> ForwardingSuperNode
-  #
-  # source://prism//lib/prism/node.rb#7484
-  sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).returns(Prism::ForwardingSuperNode) }
-  def copy(block: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7467
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { block: BlockNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7492
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7500
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#7518
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#7528
-    def type; end
-  end
-end
-
-# Represents the use of the `&&=` operator for assignment to a global variable.
-#
-#     $target &&= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#7544
-class Prism::GlobalVariableAndWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7546
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7648
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7556
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7561
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7571
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7566
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7576
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::GlobalVariableAndWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7561
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7584
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#163
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7614
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#7589
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7592
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#7609
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7599
-  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//lib/prism/node.rb#7632
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#7606
-  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//lib/prism/node.rb#7642
-    def type; end
-  end
-end
-
-# Represents assigning to a global variable using an operator that isn't `=`.
-#
-#     $target += value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#7661
-class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
-  #
-  # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7663
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7764
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7674
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#7727
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7717
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7679
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7689
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7684
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7694
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).returns(Prism::GlobalVariableOperatorWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7679
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7702
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#175
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7730
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#7707
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7710
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#387
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#394
-  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//lib/prism/node.rb#7748
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#7724
-  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//lib/prism/node.rb#7758
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to a global variable.
-#
-#     $target ||= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#7778
-class Prism::GlobalVariableOrWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7780
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7882
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7790
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7795
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7805
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7800
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#7810
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::GlobalVariableOrWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7795
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7818
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#169
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7848
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#7823
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7826
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#7843
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#7833
-  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//lib/prism/node.rb#7866
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#7840
-  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//lib/prism/node.rb#7876
-    def type; end
-  end
-end
-
-# Represents referencing a global variable.
-#
-#     $foo
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#7895
-class Prism::GlobalVariableReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#7897
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#7978
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7904
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7909
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#7919
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#7914
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> GlobalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#7924
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableReadNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#7909
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#7932
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#7944
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#7941
-  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//lib/prism/node.rb#7962
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#7972
-    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//lib/prism/node.rb#7988
-class Prism::GlobalVariableTargetNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#7990
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8067
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#7997
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8002
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8012
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8007
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> GlobalVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#8017
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableTargetNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8002
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8025
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8033
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#8030
-  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//lib/prism/node.rb#8051
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#8061
-    def type; end
-  end
-end
-
-# Represents writing to a global variable.
-#
-#     $foo = 1
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#8077
-class Prism::GlobalVariableWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
-  #
-  # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#8079
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8197
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8089
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8094
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8104
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8099
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> GlobalVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#8109
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::GlobalVariableWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8094
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8117
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8163
-  sig { override.returns(String) }
-  def inspect; 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 = :bar  # name `:$foo`
-  #
-  #     $_Test = 123 # name `:$_Test`
-  #
-  # source://prism//lib/prism/node.rb#8126
-  sig { returns(Symbol) }
-  def name; end
-
-  # The location of the global variable's name.
-  #
-  #     $foo = :bar
-  #     ^^^^
-  #
-  # source://prism//lib/prism/node.rb#8132
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#8158
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     $foo = :bar
-  #          ^
-  #
-  # source://prism//lib/prism/node.rb#8151
-  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//lib/prism/node.rb#8181
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     $foo = :bar
-  #            ^^^^
-  #
-  #     $-xyz = 123
-  #             ^^^
-  #
-  # source://prism//lib/prism/node.rb#8145
-  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//lib/prism/node.rb#8191
-    def type; end
-  end
-end
-
-# Represents a hash literal.
-#
-#     { a => b }
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#8210
-class Prism::HashNode < ::Prism::Node
-  # def initialize: (Location opening_loc, Array[AssocNode | AssocSplatNode] elements, Location closing_loc, Location location) -> void
-  #
-  # @return [HashNode] a new instance of HashNode
-  #
-  # source://prism//lib/prism/node.rb#8212
-  sig do
-    params(
-      source: Prism::Source,
-      opening_loc: Prism::Location,
-      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, opening_loc, elements, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8327
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8221
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8226
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#8288
-  sig { returns(String) }
-  def closing; end
-
-  # The location of the closing brace.
-  #
-  #     { a => b }
-  #              ^
-  #
-  # source://prism//lib/prism/node.rb#8276
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8236
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8231
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location, ?location: Location) -> HashNode
-  #
-  # source://prism//lib/prism/node.rb#8241
-  sig do
-    params(
-      opening_loc: Prism::Location,
-      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::HashNode)
-  end
-  def copy(opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8226
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8249
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
-  #
-  #     { a: b }
-  #       ^^^^
-  #
-  #     { **foo }
-  #       ^^^^^
-  #
-  # source://prism//lib/prism/node.rb#8270
-  sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
-  def elements; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8293
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#8283
-  sig { returns(String) }
-  def opening; end
-
-  # The location of the opening brace.
-  #
-  #     { a => b }
-  #     ^
-  #
-  # source://prism//lib/prism/node.rb#8257
-  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//lib/prism/node.rb#8311
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#8321
-    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//lib/prism/node.rb#8343
-class Prism::HashPatternNode < ::Prism::Node
-  # def initialize: (Prism::node? constant, Array[AssocNode] elements, AssocSplatNode | NoKeywordsParameterNode | nil rest, Location? opening_loc, Location? closing_loc, Location location) -> void
-  #
-  # @return [HashPatternNode] a new instance of HashPatternNode
-  #
-  # source://prism//lib/prism/node.rb#8345
-  sig do
-    params(
-      source: Prism::Source,
-      constant: T.nilable(Prism::Node),
-      elements: T::Array[Prism::AssocNode],
-      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, constant, elements, rest, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8472
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8356
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8361
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#8433
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#8415
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8375
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8366
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader constant: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#8393
-  sig { returns(T.nilable(Prism::Node)) }
-  def constant; end
-
-  # def copy: (?constant: Prism::node?, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> HashPatternNode
-  #
-  # source://prism//lib/prism/node.rb#8380
-  sig do
-    params(
-      constant: T.nilable(Prism::Node),
-      elements: T::Array[Prism::AssocNode],
-      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
-      opening_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::HashPatternNode)
-  end
-  def copy(constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8361
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8388
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader elements: Array[AssocNode]
-  #
-  # source://prism//lib/prism/node.rb#8396
-  sig { returns(T::Array[Prism::AssocNode]) }
-  def elements; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8438
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#8428
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#8402
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
-  #
-  # source://prism//lib/prism/node.rb#8399
-  sig { returns(T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode))) }
-  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//lib/prism/node.rb#8456
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#8466
-    def type; end
-  end
-end
-
-# source://prism//lib/prism/node_ext.rb#49
-module Prism::HeredocQuery
-  # Returns true if this node was represented as a heredoc in the source code.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node_ext.rb#51
-  def heredoc?; end
-end
-
-# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
-#
-#     bar if foo
-#     ^^^^^^^^^^
-#
-#     if foo then bar end
-#     ^^^^^^^^^^^^^^^^^^^
-#
-#     foo ? bar : baz
-#     ^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#8493
-class Prism::IfNode < ::Prism::Node
-  # def initialize: (Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, Prism::node? consequent, Location? end_keyword_loc, Location location) -> void
-  #
-  # @return [IfNode] a new instance of IfNode
-  #
-  # source://prism//lib/prism/node.rb#8495
-  sig do
-    params(
-      source: Prism::Source,
-      if_keyword_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::Node),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8687
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8507
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8512
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8526
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8517
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
-  #
-  #     if foo
-  #       bar
-  #     elsif baz
-  #     ^^^^^^^^^
-  #       qux
-  #       ^^^
-  #     end
-  #     ^^^
-  #
-  #     if foo then bar else baz end
-  #                     ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/node.rb#8617
-  sig { returns(T.nilable(Prism::Node)) }
-  def consequent; end
-
-  # def copy: (?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: Prism::node?, ?end_keyword_loc: Location?, ?location: Location) -> IfNode
-  #
-  # source://prism//lib/prism/node.rb#8531
-  sig do
-    params(
-      if_keyword_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::Node),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::IfNode)
-  end
-  def copy(if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8512
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Prism::node?, end_keyword_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8539
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#8648
-  sig { returns(T.nilable(String)) }
-  def end_keyword; end
-
-  # The location of the `end` keyword if present, `nil` otherwise.
-  #
-  #     if foo
-  #       bar
-  #     end
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#8625
-  sig { returns(T.nilable(Prism::Location)) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def if_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#8638
-  sig { returns(T.nilable(String)) }
-  def if_keyword; end
-
-  # The location of the `if` keyword if present.
-  #
-  #     bar if foo
-  #         ^^
-  #
-  # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
-  #
-  # source://prism//lib/prism/node.rb#8549
-  sig { returns(T.nilable(Prism::Location)) }
-  def if_keyword_loc; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8653
-  sig { override.returns(String) }
-  def inspect; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#91
-  def newline!(lines); end
-
-  # The node for the condition the `IfNode` is testing.
-  #
-  #     if foo
-  #        ^^^
-  #       bar
-  #     end
-  #
-  #     bar if foo
-  #            ^^^
-  #
-  #     foo ? bar : baz
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#8573
-  sig { returns(Prism::Node) }
-  def predicate; end
-
-  # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
-  #
-  #     if foo
-  #       bar
-  #       ^^^
-  #       baz
-  #       ^^^
-  #     end
-  #
-  # source://prism//lib/prism/node.rb#8602
-  sig { returns(T.nilable(Prism::StatementsNode)) }
-  def statements; end
-
-  # def then_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#8643
-  sig { returns(T.nilable(String)) }
-  def then_keyword; end
-
-  # The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
-  #
-  #     if foo then bar end
-  #            ^^^^
-  #
-  #     a ? b : c
-  #       ^
-  #
-  # source://prism//lib/prism/node.rb#8582
-  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//lib/prism/node.rb#8671
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#8681
-    def type; end
-  end
-end
-
-# Represents an imaginary number literal.
-#
-#     1.0i
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#8702
-class Prism::ImaginaryNode < ::Prism::Node
-  # def initialize: (FloatNode | IntegerNode | RationalNode numeric, Location location) -> void
-  #
-  # @return [ImaginaryNode] a new instance of ImaginaryNode
-  #
-  # source://prism//lib/prism/node.rb#8704
-  sig do
-    params(
-      source: Prism::Source,
-      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, numeric, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8781
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8711
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8716
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8726
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8721
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?numeric: FloatNode | IntegerNode | RationalNode, ?location: Location) -> ImaginaryNode
-  #
-  # source://prism//lib/prism/node.rb#8731
-  sig do
-    params(
-      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode),
-      location: Prism::Location
-    ).returns(Prism::ImaginaryNode)
-  end
-  def copy(numeric: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8716
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { numeric: FloatNode | IntegerNode | RationalNode, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8739
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8747
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader numeric: FloatNode | IntegerNode | RationalNode
-  #
-  # source://prism//lib/prism/node.rb#8744
-  sig { returns(T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)) }
-  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//lib/prism/node.rb#8765
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # Returns the value of the node as a Ruby Complex.
-  #
-  # source://prism//lib/prism/node_ext.rb#101
-  sig { returns(Complex) }
-  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//lib/prism/node.rb#8775
-    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//lib/prism/node.rb#8797
-class Prism::ImplicitNode < ::Prism::Node
-  # def initialize: (Prism::node value, Location location) -> void
-  #
-  # @return [ImplicitNode] a new instance of ImplicitNode
-  #
-  # source://prism//lib/prism/node.rb#8799
-  sig { params(source: Prism::Source, value: Prism::Node, location: Prism::Location).void }
-  def initialize(source, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8876
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8806
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8811
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8821
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8816
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Prism::node, ?location: Location) -> ImplicitNode
-  #
-  # source://prism//lib/prism/node.rb#8826
-  sig { params(value: Prism::Node, location: Prism::Location).returns(Prism::ImplicitNode) }
-  def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8811
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8834
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8842
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#8860
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#8839
-  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//lib/prism/node.rb#8870
-    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//lib/prism/node.rb#8895
-class Prism::ImplicitRestNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [ImplicitRestNode] a new instance of ImplicitRestNode
-  #
-  # source://prism//lib/prism/node.rb#8897
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#8970
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8903
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8908
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#8918
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#8913
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> ImplicitRestNode
-  #
-  # source://prism//lib/prism/node.rb#8923
-  sig { params(location: Prism::Location).returns(Prism::ImplicitRestNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8908
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#8931
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#8936
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#8954
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#8964
-    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//lib/prism/node.rb#8979
-class Prism::InNode < ::Prism::Node
-  # def initialize: (Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc, Location location) -> void
-  #
-  # @return [InNode] a new instance of InNode
-  #
-  # source://prism//lib/prism/node.rb#8981
-  sig do
-    params(
-      source: Prism::Source,
-      pattern: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      in_loc: Prism::Location,
-      then_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, pattern, statements, in_loc, then_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9097
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#8991
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8996
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9009
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9001
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?, ?location: Location) -> InNode
-  #
-  # source://prism//lib/prism/node.rb#9014
-  sig do
-    params(
-      pattern: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      in_loc: Prism::Location,
-      then_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::InNode)
-  end
-  def copy(pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#8996
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9022
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def in: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9053
-  sig { returns(String) }
-  def in; end
-
-  # attr_reader in_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9033
-  sig { returns(Prism::Location) }
-  def in_loc; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9063
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader pattern: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9027
-  sig { returns(Prism::Node) }
-  def pattern; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#9030
-  sig { returns(T.nilable(Prism::StatementsNode)) }
-  def statements; end
-
-  # def then: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#9058
-  sig { returns(T.nilable(String)) }
-  def then; end
-
-  # attr_reader then_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#9040
-  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//lib/prism/node.rb#9081
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#9091
-    def type; end
-  end
-end
-
-# Represents the use of the `&&=` operator on a call to the `[]` method.
-#
-#     foo.bar[baz] &&= value
-#     ^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#9110
-class Prism::IndexAndWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9112
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9289
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9127
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#9192
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9225
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9202
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#9235
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#9172
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9132
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9245
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9195
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9147
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9137
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9152
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::IndexAndWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9132
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9160
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9230
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9255
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9240
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9185
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9250
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9205
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9169
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9215
-  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//lib/prism/node.rb#9273
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9212
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9220
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#9165
-  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//lib/prism/node.rb#9283
-    def type; end
-  end
-end
-
-# Represents the use of an assignment operator on a call to `[]`.
-#
-#     foo.bar[baz] += value
-#     ^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#9307
-class Prism::IndexOperatorWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9309
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      binary_operator: Symbol,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9485
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9325
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#9390
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9426
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#9403
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9406
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9400
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#9436
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#9370
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9330
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9446
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9393
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9345
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9335
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9350
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      binary_operator: Symbol,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::IndexOperatorWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9330
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9358
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9431
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9451
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9441
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9383
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#403
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#410
-  def operator_loc; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9367
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9416
-  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//lib/prism/node.rb#9469
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9413
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9421
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#9363
-  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//lib/prism/node.rb#9479
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator on a call to `[]`.
-#
-#     foo.bar[baz] ||= value
-#     ^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#9504
-class Prism::IndexOrWriteNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9506
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9683
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9521
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#9586
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9619
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9596
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def call_operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#9629
-  sig { returns(T.nilable(String)) }
-  def call_operator; end
-
-  # attr_reader call_operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#9566
-  sig { returns(T.nilable(Prism::Location)) }
-  def call_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9526
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9639
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9589
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9541
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9531
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9546
-  sig do
-    params(
-      flags: Integer,
-      receiver: T.nilable(Prism::Node),
-      call_operator_loc: T.nilable(Prism::Location),
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::IndexOrWriteNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9526
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9554
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9624
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9649
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9634
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9579
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9644
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9599
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader receiver: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9563
-  sig { returns(T.nilable(Prism::Node)) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9609
-  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//lib/prism/node.rb#9667
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9606
-  sig { returns(Prism::Node) }
-  def value; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9614
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#9559
-  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//lib/prism/node.rb#9677
-    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//lib/prism/node.rb#9709
-class Prism::IndexTargetNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location location) -> void
-  #
-  # @return [IndexTargetNode] a new instance of IndexTargetNode
-  #
-  # source://prism//lib/prism/node.rb#9711
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      receiver: Prism::Node,
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, receiver, opening_loc, arguments, closing_loc, block, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9851
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9723
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#9774
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def attribute_write?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9797
-  sig { returns(T::Boolean) }
-  def attribute_write?; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#9784
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9728
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9812
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9777
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9742
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9733
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?location: Location) -> IndexTargetNode
-  #
-  # source://prism//lib/prism/node.rb#9747
-  sig do
-    params(
-      flags: Integer,
-      receiver: Prism::Node,
-      opening_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      closing_loc: Prism::Location,
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).returns(Prism::IndexTargetNode)
-  end
-  def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9728
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9755
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def ignore_visibility?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9802
-  sig { returns(T::Boolean) }
-  def ignore_visibility?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9817
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9807
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9767
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader receiver: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9764
-  sig { returns(Prism::Node) }
-  def receiver; end
-
-  # def safe_navigation?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9787
-  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//lib/prism/node.rb#9835
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # def variable_call?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#9792
-  sig { returns(T::Boolean) }
-  def variable_call?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#9760
-  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//lib/prism/node.rb#9845
-    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//lib/prism/parse_result.rb#388
-class Prism::InlineComment < ::Prism::Comment
-  # Returns a string representation of this comment.
-  #
-  # source://prism//lib/prism/parse_result.rb#396
-  sig { returns(String) }
-  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//lib/prism/parse_result.rb#391
-  sig { override.returns(T::Boolean) }
-  def trailing?; end
-end
-
-# This visitor is responsible for composing the strings that get returned by
-# the various #inspect methods defined on each of the nodes.
-#
-# source://prism//lib/prism/inspect_visitor.rb#12
-class Prism::InspectVisitor < ::Prism::Visitor
-  # Initializes a new instance of the InspectVisitor.
-  #
-  # @return [InspectVisitor] a new instance of InspectVisitor
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#35
-  sig { params(indent: String).void }
-  def initialize(indent = T.unsafe(nil)); end
-
-  # The list of commands that we need to execute in order to compose the
-  # final string.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#32
-  def commands; end
-
-  # Compose the final string.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#48
-  sig { returns(String) }
-  def compose; end
-
-  # The current prefix string.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#28
-  def indent; end
-
-  # Inspect a AliasGlobalVariableNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#77
-  def visit_alias_global_variable_node(node); end
-
-  # Inspect a AliasMethodNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#87
-  def visit_alias_method_node(node); end
-
-  # Inspect a AlternationPatternNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#97
-  def visit_alternation_pattern_node(node); end
-
-  # Inspect a AndNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#107
-  def visit_and_node(node); end
-
-  # Inspect a ArgumentsNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#117
-  def visit_arguments_node(node); end
-
-  # Inspect a ArrayNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#133
-  def visit_array_node(node); end
-
-  # Inspect a ArrayPatternNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#151
-  def visit_array_pattern_node(node); end
-
-  # Inspect a AssocNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#188
-  def visit_assoc_node(node); end
-
-  # Inspect a AssocSplatNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#198
-  def visit_assoc_splat_node(node); end
-
-  # Inspect a BackReferenceReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#210
-  def visit_back_reference_read_node(node); end
-
-  # Inspect a BeginNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#216
-  def visit_begin_node(node); end
-
-  # Inspect a BlockArgumentNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#247
-  def visit_block_argument_node(node); end
-
-  # Inspect a BlockLocalVariableNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#259
-  def visit_block_local_variable_node(node); end
-
-  # Inspect a BlockNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#267
-  def visit_block_node(node); end
-
-  # Inspect a BlockParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#287
-  def visit_block_parameter_node(node); end
-
-  # Inspect a BlockParametersNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#301
-  def visit_block_parameters_node(node); end
-
-  # Inspect a BreakNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#323
-  def visit_break_node(node); end
-
-  # Inspect a CallAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#335
-  def visit_call_and_write_node(node); end
-
-  # Inspect a CallNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#355
-  def visit_call_node(node); end
-
-  # Inspect a CallOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#385
-  def visit_call_operator_write_node(node); end
-
-  # Inspect a CallOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#406
-  def visit_call_or_write_node(node); end
-
-  # Inspect a CallTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#426
-  def visit_call_target_node(node); end
-
-  # Inspect a CapturePatternNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#438
-  def visit_capture_pattern_node(node); end
-
-  # Inspect a CaseMatchNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#448
-  def visit_case_match_node(node); end
-
-  # Inspect a CaseNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#476
-  def visit_case_node(node); end
-
-  # Inspect a ClassNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#504
-  def visit_class_node(node); end
-
-  # Inspect a ClassVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#528
-  def visit_class_variable_and_write_node(node); end
-
-  # Inspect a ClassVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#538
-  def visit_class_variable_operator_write_node(node); end
-
-  # Inspect a ClassVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#549
-  def visit_class_variable_or_write_node(node); end
-
-  # Inspect a ClassVariableReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#559
-  def visit_class_variable_read_node(node); end
-
-  # Inspect a ClassVariableTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#565
-  def visit_class_variable_target_node(node); end
-
-  # Inspect a ClassVariableWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#571
-  def visit_class_variable_write_node(node); end
-
-  # Inspect a ConstantAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#581
-  def visit_constant_and_write_node(node); end
-
-  # Inspect a ConstantOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#591
-  def visit_constant_operator_write_node(node); end
-
-  # Inspect a ConstantOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#602
-  def visit_constant_or_write_node(node); end
-
-  # Inspect a ConstantPathAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#612
-  def visit_constant_path_and_write_node(node); end
-
-  # Inspect a ConstantPathNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#622
-  def visit_constant_path_node(node); end
-
-  # Inspect a ConstantPathOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#640
-  def visit_constant_path_operator_write_node(node); end
-
-  # Inspect a ConstantPathOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#651
-  def visit_constant_path_or_write_node(node); end
-
-  # Inspect a ConstantPathTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#661
-  def visit_constant_path_target_node(node); end
-
-  # Inspect a ConstantPathWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#679
-  def visit_constant_path_write_node(node); end
-
-  # Inspect a ConstantReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#689
-  def visit_constant_read_node(node); end
-
-  # Inspect a ConstantTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#695
-  def visit_constant_target_node(node); end
-
-  # Inspect a ConstantWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#701
-  def visit_constant_write_node(node); end
-
-  # Inspect a DefNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#711
-  def visit_def_node(node); end
-
-  # Inspect a DefinedNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#743
-  def visit_defined_node(node); end
-
-  # Inspect a ElseNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#753
-  def visit_else_node(node); end
-
-  # Inspect a EmbeddedStatementsNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#766
-  def visit_embedded_statements_node(node); end
-
-  # Inspect a EmbeddedVariableNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#779
-  def visit_embedded_variable_node(node); end
-
-  # Inspect a EnsureNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#787
-  def visit_ensure_node(node); end
-
-  # Inspect a FalseNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#800
-  def visit_false_node(node); end
-
-  # Inspect a FindPatternNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#805
-  def visit_find_pattern_node(node); end
-
-  # Inspect a FlipFlopNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#831
-  def visit_flip_flop_node(node); end
-
-  # Inspect a FloatNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#851
-  def visit_float_node(node); end
-
-  # Inspect a ForNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#857
-  def visit_for_node(node); end
-
-  # Inspect a ForwardingArgumentsNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#876
-  def visit_forwarding_arguments_node(node); end
-
-  # Inspect a ForwardingParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#881
-  def visit_forwarding_parameter_node(node); end
-
-  # Inspect a ForwardingSuperNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#886
-  def visit_forwarding_super_node(node); end
-
-  # Inspect a GlobalVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#897
-  def visit_global_variable_and_write_node(node); end
-
-  # Inspect a GlobalVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#907
-  def visit_global_variable_operator_write_node(node); end
-
-  # Inspect a GlobalVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#918
-  def visit_global_variable_or_write_node(node); end
-
-  # Inspect a GlobalVariableReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#928
-  def visit_global_variable_read_node(node); end
-
-  # Inspect a GlobalVariableTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#934
-  def visit_global_variable_target_node(node); end
-
-  # Inspect a GlobalVariableWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#940
-  def visit_global_variable_write_node(node); end
-
-  # Inspect a HashNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#950
-  def visit_hash_node(node); end
-
-  # Inspect a HashPatternNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#966
-  def visit_hash_pattern_node(node); end
-
-  # Inspect a IfNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#994
-  def visit_if_node(node); end
-
-  # Inspect a ImaginaryNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1016
-  def visit_imaginary_node(node); end
-
-  # Inspect a ImplicitNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1023
-  def visit_implicit_node(node); end
-
-  # Inspect a ImplicitRestNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1030
-  def visit_implicit_rest_node(node); end
-
-  # Inspect a InNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1035
-  def visit_in_node(node); end
-
-  # Inspect a IndexAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1050
-  def visit_index_and_write_node(node); end
-
-  # Inspect a IndexOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1081
-  def visit_index_operator_write_node(node); end
-
-  # Inspect a IndexOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1113
-  def visit_index_or_write_node(node); end
-
-  # Inspect a IndexTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1144
-  def visit_index_target_node(node); end
-
-  # Inspect a InstanceVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1167
-  def visit_instance_variable_and_write_node(node); end
-
-  # Inspect a InstanceVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1177
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Inspect a InstanceVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1188
-  def visit_instance_variable_or_write_node(node); end
-
-  # Inspect a InstanceVariableReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1198
-  def visit_instance_variable_read_node(node); end
-
-  # Inspect a InstanceVariableTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1204
-  def visit_instance_variable_target_node(node); end
-
-  # Inspect a InstanceVariableWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1210
-  def visit_instance_variable_write_node(node); end
-
-  # Inspect a IntegerNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1220
-  def visit_integer_node(node); end
-
-  # Inspect a InterpolatedMatchLastLineNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1228
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Inspect a InterpolatedRegularExpressionNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1246
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Inspect a InterpolatedStringNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1264
-  def visit_interpolated_string_node(node); end
-
-  # Inspect a InterpolatedSymbolNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1282
-  def visit_interpolated_symbol_node(node); end
-
-  # Inspect a InterpolatedXStringNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1298
-  def visit_interpolated_x_string_node(node); end
-
-  # Inspect a ItLocalVariableReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1314
-  def visit_it_local_variable_read_node(node); end
-
-  # Inspect a ItParametersNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1319
-  def visit_it_parameters_node(node); end
-
-  # Inspect a KeywordHashNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1324
-  def visit_keyword_hash_node(node); end
-
-  # Inspect a KeywordRestParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1340
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Inspect a LambdaNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1354
-  def visit_lambda_node(node); end
-
-  # Inspect a LocalVariableAndWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1375
-  def visit_local_variable_and_write_node(node); end
-
-  # Inspect a LocalVariableOperatorWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1386
-  def visit_local_variable_operator_write_node(node); end
-
-  # Inspect a LocalVariableOrWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1398
-  def visit_local_variable_or_write_node(node); end
-
-  # Inspect a LocalVariableReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1409
-  def visit_local_variable_read_node(node); end
-
-  # Inspect a LocalVariableTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1416
-  def visit_local_variable_target_node(node); end
-
-  # Inspect a LocalVariableWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1423
-  def visit_local_variable_write_node(node); end
-
-  # Inspect a MatchLastLineNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1434
-  def visit_match_last_line_node(node); end
-
-  # Inspect a MatchPredicateNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1445
-  def visit_match_predicate_node(node); end
-
-  # Inspect a MatchRequiredNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1455
-  def visit_match_required_node(node); end
-
-  # Inspect a MatchWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1465
-  def visit_match_write_node(node); end
-
-  # Inspect a MissingNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1481
-  def visit_missing_node(node); end
-
-  # Inspect a ModuleNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1486
-  def visit_module_node(node); end
-
-  # Inspect a MultiTargetNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1503
-  def visit_multi_target_node(node); end
-
-  # Inspect a MultiWriteNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1534
-  def visit_multi_write_node(node); end
-
-  # Inspect a NextNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1568
-  def visit_next_node(node); end
-
-  # Inspect a NilNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1580
-  def visit_nil_node(node); end
-
-  # Inspect a NoKeywordsParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1585
-  def visit_no_keywords_parameter_node(node); end
-
-  # Inspect a NumberedParametersNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1592
-  def visit_numbered_parameters_node(node); end
-
-  # Inspect a NumberedReferenceReadNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1598
-  def visit_numbered_reference_read_node(node); end
-
-  # Inspect a OptionalKeywordParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1604
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Inspect a OptionalParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1615
-  def visit_optional_parameter_node(node); end
-
-  # Inspect a OrNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1627
-  def visit_or_node(node); end
-
-  # Inspect a ParametersNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1637
-  def visit_parameters_node(node); end
-
-  # Inspect a ParenthesesNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1696
-  def visit_parentheses_node(node); end
-
-  # Inspect a PinnedExpressionNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1709
-  def visit_pinned_expression_node(node); end
-
-  # Inspect a PinnedVariableNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1719
-  def visit_pinned_variable_node(node); end
-
-  # Inspect a PostExecutionNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1727
-  def visit_post_execution_node(node); end
-
-  # Inspect a PreExecutionNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1741
-  def visit_pre_execution_node(node); end
-
-  # Inspect a ProgramNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1755
-  def visit_program_node(node); end
-
-  # Inspect a RangeNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1763
-  def visit_range_node(node); end
-
-  # Inspect a RationalNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1783
-  def visit_rational_node(node); end
-
-  # Inspect a RedoNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1792
-  def visit_redo_node(node); end
-
-  # Inspect a RegularExpressionNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1797
-  def visit_regular_expression_node(node); end
-
-  # Inspect a RequiredKeywordParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1808
-  def visit_required_keyword_parameter_node(node); end
-
-  # Inspect a RequiredParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1817
-  def visit_required_parameter_node(node); end
-
-  # Inspect a RescueModifierNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1825
-  def visit_rescue_modifier_node(node); end
-
-  # Inspect a RescueNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1835
-  def visit_rescue_node(node); end
-
-  # Inspect a RestParameterNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1869
-  def visit_rest_parameter_node(node); end
-
-  # Inspect a RetryNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1883
-  def visit_retry_node(node); end
-
-  # Inspect a ReturnNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1888
-  def visit_return_node(node); end
-
-  # Inspect a SelfNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1902
-  def visit_self_node(node); end
-
-  # Inspect a ShareableConstantNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1907
-  def visit_shareable_constant_node(node); end
-
-  # Inspect a SingletonClassNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1916
-  def visit_singleton_class_node(node); end
-
-  # Inspect a SourceEncodingNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1933
-  def visit_source_encoding_node(node); end
-
-  # Inspect a SourceFileNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1938
-  def visit_source_file_node(node); end
-
-  # Inspect a SourceLineNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1946
-  def visit_source_line_node(node); end
-
-  # Inspect a SplatNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1951
-  def visit_splat_node(node); end
-
-  # Inspect a StatementsNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1963
-  def visit_statements_node(node); end
-
-  # Inspect a StringNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1977
-  def visit_string_node(node); end
-
-  # Inspect a SuperNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#1988
-  def visit_super_node(node); end
-
-  # Inspect a SymbolNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2008
-  def visit_symbol_node(node); end
-
-  # Inspect a TrueNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2019
-  def visit_true_node(node); end
-
-  # Inspect a UndefNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2024
-  def visit_undef_node(node); end
-
-  # Inspect a UnlessNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2039
-  def visit_unless_node(node); end
-
-  # Inspect a UntilNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2061
-  def visit_until_node(node); end
-
-  # Inspect a WhenNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2078
-  def visit_when_node(node); end
-
-  # Inspect a WhileNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2100
-  def visit_while_node(node); end
-
-  # Inspect a XStringNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2117
-  def visit_x_string_node(node); end
-
-  # Inspect a YieldNode node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2128
-  def visit_yield_node(node); end
-
-  private
-
-  # Compose a string representing the given inner location field.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2150
-  def inspect_location(location); end
-
-  # Compose a header for the given node.
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#2144
-  def inspect_node(name, node); end
-
-  class << self
-    # Compose an inspect string for the given node.
-    #
-    # source://prism//lib/prism/inspect_visitor.rb#41
-    sig { params(node: Prism::Node).returns(String) }
-    def compose(node); end
-  end
-end
-
-# Most of the time, we can simply pass down the indent to the next node.
-# However, when we are inside a list we want some extra special formatting
-# when we hit an element in that list. In this case, we have a special
-# command that replaces the subsequent indent with the given value.
-#
-# source://prism//lib/prism/inspect_visitor.rb#17
-class Prism::InspectVisitor::Replace
-  # @return [Replace] a new instance of Replace
-  #
-  # source://prism//lib/prism/inspect_visitor.rb#20
-  def initialize(value); end
-
-  # source://prism//lib/prism/inspect_visitor.rb#18
-  def value; end
-end
-
-# Represents the use of the `&&=` operator for assignment to an instance variable.
-#
-#     @target &&= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#9866
-class Prism::InstanceVariableAndWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9868
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#9970
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9878
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9883
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#9893
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#9888
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9898
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::InstanceVariableAndWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#9883
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#9906
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#181
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#9936
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#9911
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9914
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#9931
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#9921
-  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//lib/prism/node.rb#9954
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#9928
-  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//lib/prism/node.rb#9964
-    def type; end
-  end
-end
-
-# Represents assigning to an instance variable using an operator that isn't `=`.
-#
-#     @target += value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#9983
-class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
-  #
-  # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#9985
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10086
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#9996
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#10049
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10039
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10001
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10011
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10006
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#10016
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      binary_operator: Symbol,
-      location: Prism::Location
-    ).returns(Prism::InstanceVariableOperatorWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10001
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10024
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#193
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10052
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#10029
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10032
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#419
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#426
-  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//lib/prism/node.rb#10070
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#10046
-  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//lib/prism/node.rb#10080
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to an instance variable.
-#
-#     @target ||= value
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#10100
-class Prism::InstanceVariableOrWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#10102
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10204
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10112
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10117
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10127
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10122
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#10132
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::InstanceVariableOrWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10117
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10140
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # source://prism//lib/prism/desugar_compiler.rb#187
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10170
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#10145
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10148
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10165
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10155
-  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//lib/prism/node.rb#10188
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#10162
-  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//lib/prism/node.rb#10198
-    def type; end
-  end
-end
-
-# Represents referencing an instance variable.
-#
-#     @foo
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#10217
-class Prism::InstanceVariableReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#10219
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10300
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10226
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10231
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10241
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10236
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> InstanceVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#10246
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableReadNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10231
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10254
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10266
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#10263
-  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//lib/prism/node.rb#10284
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#10294
-    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//lib/prism/node.rb#10310
-class Prism::InstanceVariableTargetNode < ::Prism::Node
-  # def initialize: (Symbol name, Location location) -> void
-  #
-  # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#10312
-  sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
-  def initialize(source, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10389
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10319
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10324
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10334
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10329
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?location: Location) -> InstanceVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#10339
-  sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableTargetNode) }
-  def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10324
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10347
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10355
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#10352
-  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//lib/prism/node.rb#10373
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#10383
-    def type; end
-  end
-end
-
-# Represents writing to an instance variable.
-#
-#     @foo = 1
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#10399
-class Prism::InstanceVariableWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
-  #
-  # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#10401
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, name_loc, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10519
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10411
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10416
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10426
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10421
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> InstanceVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#10431
-  sig do
-    params(
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::InstanceVariableWriteNode)
-  end
-  def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10416
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10439
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10485
-  sig { override.returns(String) }
-  def inspect; 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 = :y       # name `:@x`
-  #
-  #     @_foo = "bar" # name `@_foo`
-  #
-  # source://prism//lib/prism/node.rb#10448
-  sig { returns(Symbol) }
-  def name; end
-
-  # The location of the variable name.
-  #
-  #     @_x = 1
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#10454
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10480
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     @x = y
-  #        ^
-  #
-  # source://prism//lib/prism/node.rb#10473
-  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//lib/prism/node.rb#10503
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     @foo = :bar
-  #            ^^^^
-  #
-  #     @_x = 1234
-  #           ^^^^
-  #
-  # source://prism//lib/prism/node.rb#10467
-  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//lib/prism/node.rb#10513
-    def type; end
-  end
-end
-
-# Flags for integer nodes that correspond to the base of the integer.
-#
-# source://prism//lib/prism/node.rb#19166
-module Prism::IntegerBaseFlags; end
-
-# 0b prefix
-#
-# source://prism//lib/prism/node.rb#19168
-Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
-
-# 0d or no prefix
-#
-# source://prism//lib/prism/node.rb#19171
-Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
-
-# 0x prefix
-#
-# source://prism//lib/prism/node.rb#19177
-Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
-
-# 0o or 0 prefix
-#
-# source://prism//lib/prism/node.rb#19174
-Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
-
-# Represents an integer number literal.
-#
-#     1
-#     ^
-#
-# source://prism//lib/prism/node.rb#10532
-class Prism::IntegerNode < ::Prism::Node
-  # def initialize: (Integer flags, Integer value, Location location) -> void
-  #
-  # @return [IntegerNode] a new instance of IntegerNode
-  #
-  # source://prism//lib/prism/node.rb#10534
-  sig { params(source: Prism::Source, flags: Integer, value: Integer, location: Prism::Location).void }
-  def initialize(source, flags, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10636
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10542
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def binary?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10582
-  sig { returns(T::Boolean) }
-  def binary?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10547
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10557
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10552
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?value: Integer, ?location: Location) -> IntegerNode
-  #
-  # source://prism//lib/prism/node.rb#10562
-  sig { params(flags: Integer, value: Integer, location: Prism::Location).returns(Prism::IntegerNode) }
-  def copy(flags: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def decimal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10587
-  sig { returns(T::Boolean) }
-  def decimal?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10547
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, value: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10570
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def hexadecimal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10597
-  sig { returns(T::Boolean) }
-  def hexadecimal?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10602
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def octal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10592
-  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//lib/prism/node.rb#10620
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value of the integer literal as a number.
-  #
-  # source://prism//lib/prism/node.rb#10579
-  sig { returns(Integer) }
-  def value; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#10575
-  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//lib/prism/node.rb#10630
-    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//lib/prism/node.rb#10647
-class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
-  include ::Prism::RegularExpressionOptions
-
-  # def initialize: (Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
-  #
-  # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
-  #
-  # source://prism//lib/prism/node.rb#10649
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, parts, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10812
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10659
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def ascii_8bit?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10738
-  sig { returns(T::Boolean) }
-  def ascii_8bit?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10664
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10773
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10706
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10674
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10669
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedMatchLastLineNode
-  #
-  # source://prism//lib/prism/node.rb#10679
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::InterpolatedMatchLastLineNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10664
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10687
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def euc_jp?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10733
-  sig { returns(T::Boolean) }
-  def euc_jp?; end
-
-  # def extended?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10718
-  sig { returns(T::Boolean) }
-  def extended?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10758
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_us_ascii_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10763
-  sig { returns(T::Boolean) }
-  def forced_us_ascii_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10753
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def ignore_case?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10713
-  sig { returns(T::Boolean) }
-  def ignore_case?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10778
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def multi_line?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10723
-  sig { returns(T::Boolean) }
-  def multi_line?; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#121
-  def newline!(lines); end
-
-  # def once?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10728
-  sig { returns(T::Boolean) }
-  def once?; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10768
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10696
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  sig { returns(Integer) }
-  def options; end
-
-  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
-  #
-  # source://prism//lib/prism/node.rb#10703
-  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
-  def parts; 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//lib/prism/node.rb#10796
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # def utf_8?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10748
-  sig { returns(T::Boolean) }
-  def utf_8?; end
-
-  # def windows_31j?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10743
-  sig { returns(T::Boolean) }
-  def windows_31j?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#10692
-  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//lib/prism/node.rb#10806
-    def type; end
-  end
-end
-
-# Represents a regular expression literal that contains interpolation.
-#
-#     /foo #{bar} baz/
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#10826
-class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
-  include ::Prism::RegularExpressionOptions
-
-  # def initialize: (Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
-  #
-  # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
-  #
-  # source://prism//lib/prism/node.rb#10828
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, parts, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#10991
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#10838
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def ascii_8bit?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10917
-  sig { returns(T::Boolean) }
-  def ascii_8bit?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10843
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10952
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10885
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#10853
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#10848
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedRegularExpressionNode
-  #
-  # source://prism//lib/prism/node.rb#10858
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::InterpolatedRegularExpressionNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#10843
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#10866
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def euc_jp?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10912
-  sig { returns(T::Boolean) }
-  def euc_jp?; end
-
-  # def extended?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10897
-  sig { returns(T::Boolean) }
-  def extended?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10937
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_us_ascii_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10942
-  sig { returns(T::Boolean) }
-  def forced_us_ascii_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10932
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def ignore_case?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10892
-  sig { returns(T::Boolean) }
-  def ignore_case?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#10957
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def multi_line?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10902
-  sig { returns(T::Boolean) }
-  def multi_line?; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#128
-  def newline!(lines); end
-
-  # def once?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10907
-  sig { returns(T::Boolean) }
-  def once?; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#10947
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#10875
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  sig { returns(Integer) }
-  def options; end
-
-  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
-  #
-  # source://prism//lib/prism/node.rb#10882
-  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
-  def parts; 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//lib/prism/node.rb#10975
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # def utf_8?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10927
-  sig { returns(T::Boolean) }
-  def utf_8?; end
-
-  # def windows_31j?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#10922
-  sig { returns(T::Boolean) }
-  def windows_31j?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#10871
-  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//lib/prism/node.rb#10985
-    def type; end
-  end
-end
-
-# Represents a string literal that contains interpolation.
-#
-#     "foo #{bar} baz"
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11005
-class Prism::InterpolatedStringNode < ::Prism::Node
-  include ::Prism::HeredocQuery
-
-  # def initialize: (Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode] parts, Location? closing_loc, Location location) -> void
-  #
-  # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
-  #
-  # source://prism//lib/prism/node.rb#11007
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, parts, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11137
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11017
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11022
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#11098
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#11070
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11032
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11027
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedStringNode
-  #
-  # source://prism//lib/prism/node.rb#11037
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::InterpolatedStringNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11022
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11045
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def frozen?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#11083
-  sig { returns(T::Boolean) }
-  def frozen?; end
-
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11103
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def mutable?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#11088
-  sig { returns(T::Boolean) }
-  def mutable?; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#135
-  def newline!(lines); end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#11093
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#11054
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode]
-  #
-  # source://prism//lib/prism/node.rb#11067
-  sig do
-    returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)])
-  end
-  def parts; 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//lib/prism/node.rb#11121
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#11050
-  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//lib/prism/node.rb#11131
-    def type; end
-  end
-end
-
-# Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
-#
-# source://prism//lib/prism/node.rb#19181
-module Prism::InterpolatedStringNodeFlags; end
-
-# source://prism//lib/prism/node.rb#19183
-Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer)
-
-# source://prism//lib/prism/node.rb#19186
-Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
-
-# Represents a symbol literal that contains interpolation.
-#
-#     :"foo #{bar} baz"
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11151
-class Prism::InterpolatedSymbolNode < ::Prism::Node
-  # def initialize: (Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location? closing_loc, Location location) -> void
-  #
-  # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
-  #
-  # source://prism//lib/prism/node.rb#11153
-  sig do
-    params(
-      source: Prism::Source,
-      opening_loc: T.nilable(Prism::Location),
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, opening_loc, parts, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11268
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11162
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11167
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#11229
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#11211
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11177
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11172
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedSymbolNode
-  #
-  # source://prism//lib/prism/node.rb#11182
-  sig do
-    params(
-      opening_loc: T.nilable(Prism::Location),
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::InterpolatedSymbolNode)
-  end
-  def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11167
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11190
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11234
-  sig { override.returns(String) }
-  def inspect; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#142
-  def newline!(lines); end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#11224
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#11195
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
-  #
-  # source://prism//lib/prism/node.rb#11208
-  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
-  def parts; 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//lib/prism/node.rb#11252
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#11262
-    def type; end
-  end
-end
-
-# Represents an xstring literal that contains interpolation.
-#
-#     `foo #{bar} baz`
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11281
-class Prism::InterpolatedXStringNode < ::Prism::Node
-  include ::Prism::HeredocQuery
-
-  # def initialize: (Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
-  #
-  # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
-  #
-  # source://prism//lib/prism/node.rb#11283
-  sig do
-    params(
-      source: Prism::Source,
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, opening_loc, parts, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11386
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11292
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11297
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11347
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11335
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11307
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11302
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedXStringNode
-  #
-  # source://prism//lib/prism/node.rb#11312
-  sig do
-    params(
-      opening_loc: Prism::Location,
-      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::InterpolatedXStringNode)
-  end
-  def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11297
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11320
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11352
-  sig { override.returns(String) }
-  def inspect; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#149
-  def newline!(lines); end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11342
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11325
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
-  #
-  # source://prism//lib/prism/node.rb#11332
-  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
-  def parts; 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//lib/prism/node.rb#11370
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#11380
-    def type; end
-  end
-end
-
-# Represents reading from the implicit `it` local variable.
-#
-#     -> { it }
-#          ^^
-#
-# source://prism//lib/prism/node.rb#11399
-class Prism::ItLocalVariableReadNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [ItLocalVariableReadNode] a new instance of ItLocalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#11401
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11474
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11407
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11412
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11422
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11417
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> ItLocalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#11427
-  sig { params(location: Prism::Location).returns(Prism::ItLocalVariableReadNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11412
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11435
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11440
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#11458
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#11468
-    def type; end
-  end
-end
-
-# Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
-#
-#     -> { it + it }
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11483
-class Prism::ItParametersNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [ItParametersNode] a new instance of ItParametersNode
-  #
-  # source://prism//lib/prism/node.rb#11485
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11558
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11491
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11496
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11506
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11501
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> ItParametersNode
-  #
-  # source://prism//lib/prism/node.rb#11511
-  sig { params(location: Prism::Location).returns(Prism::ItParametersNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11496
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11519
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11524
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#11542
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#11552
-    def type; end
-  end
-end
-
-# Represents a hash literal without opening and closing braces.
-#
-#     foo(a: b)
-#         ^^^^
-#
-# source://prism//lib/prism/node.rb#11567
-class Prism::KeywordHashNode < ::Prism::Node
-  # def initialize: (Integer flags, Array[AssocNode | AssocSplatNode] elements, Location location) -> void
-  #
-  # @return [KeywordHashNode] a new instance of KeywordHashNode
-  #
-  # source://prism//lib/prism/node.rb#11569
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, elements, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11656
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11577
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11582
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11592
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11587
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode], ?location: Location) -> KeywordHashNode
-  #
-  # source://prism//lib/prism/node.rb#11597
-  sig do
-    params(
-      flags: Integer,
-      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
-      location: Prism::Location
-    ).returns(Prism::KeywordHashNode)
-  end
-  def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11582
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[AssocNode | AssocSplatNode], location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11605
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader elements: Array[AssocNode | AssocSplatNode]
-  #
-  # source://prism//lib/prism/node.rb#11614
-  sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
-  def elements; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11622
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def symbol_keys?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#11617
-  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//lib/prism/node.rb#11640
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#11610
-  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//lib/prism/node.rb#11650
-    def type; end
-  end
-end
-
-# Flags for keyword hash nodes.
-#
-# source://prism//lib/prism/node.rb#19190
-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//lib/prism/node.rb#19192
-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//lib/prism/node.rb#11669
-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//lib/prism/node.rb#11671
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11785
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11681
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11686
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11696
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11691
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> KeywordRestParameterNode
-  #
-  # source://prism//lib/prism/node.rb#11701
-  sig do
-    params(
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::KeywordRestParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11686
-  sig { override.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//lib/prism/node.rb#11709
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11751
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol?
-  #
-  # source://prism//lib/prism/node.rb#11718
-  sig { returns(T.nilable(Symbol)) }
-  def name; end
-
-  # attr_reader name_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#11721
-  sig { returns(T.nilable(Prism::Location)) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11746
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11734
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#11741
-  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//lib/prism/node.rb#11769
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#11714
-  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//lib/prism/node.rb#11779
-    def type; end
-  end
-end
-
-# Represents using a lambda literal (not the lambda method call).
-#
-#     ->(value) { value * 2 }
-#     ^^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11798
-class Prism::LambdaNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, Prism::node? parameters, Prism::node? body, Location location) -> void
-  #
-  # @return [LambdaNode] a new instance of LambdaNode
-  #
-  # source://prism//lib/prism/node.rb#11800
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      operator_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      parameters: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#11927
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11812
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#11875
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11817
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11888
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11865
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11830
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11822
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: Prism::node?, ?body: Prism::node?, ?location: Location) -> LambdaNode
-  #
-  # source://prism//lib/prism/node.rb#11835
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      operator_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      parameters: T.nilable(Prism::Node),
-      body: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).returns(Prism::LambdaNode)
-  end
-  def copy(locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11817
-  sig { override.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: Prism::node?, body: Prism::node?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11843
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#11893
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#11848
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11883
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11858
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#11878
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11851
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader parameters: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#11872
-  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//lib/prism/node.rb#11911
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#11921
-    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//lib/prism/lex_compat.rb#12
-class Prism::LexCompat
-  # @return [LexCompat] a new instance of LexCompat
-  #
-  # source://prism//lib/prism/lex_compat.rb#619
-  def initialize(source, **options); end
-
-  # Returns the value of attribute options.
-  #
-  # source://prism//lib/prism/lex_compat.rb#617
-  def options; end
-
-  # source://prism//lib/prism/lex_compat.rb#624
-  def result; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/lex_compat.rb#617
-  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//lib/prism/lex_compat.rb#230
-class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
-  # source://prism//lib/prism/lex_compat.rb#231
-  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//lib/prism/lex_compat.rb#291
-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//lib/prism/lex_compat.rb#603
-    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//lib/prism/lex_compat.rb#315
-class Prism::LexCompat::Heredoc::DashHeredoc
-  # @return [DashHeredoc] a new instance of DashHeredoc
-  #
-  # source://prism//lib/prism/lex_compat.rb#318
-  def initialize(split); end
-
-  # source://prism//lib/prism/lex_compat.rb#323
-  def <<(token); end
-
-  # source://prism//lib/prism/lex_compat.rb#316
-  def split; end
-
-  # source://prism//lib/prism/lex_compat.rb#327
-  def to_a; end
-
-  # source://prism//lib/prism/lex_compat.rb#316
-  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//lib/prism/lex_compat.rb#374
-class Prism::LexCompat::Heredoc::DedentingHeredoc
-  # @return [DedentingHeredoc] a new instance of DedentingHeredoc
-  #
-  # source://prism//lib/prism/lex_compat.rb#379
-  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//lib/prism/lex_compat.rb#390
-  def <<(token); end
-
-  # Returns the value of attribute dedent.
-  #
-  # source://prism//lib/prism/lex_compat.rb#377
-  def dedent; end
-
-  # Returns the value of attribute dedent_next.
-  #
-  # source://prism//lib/prism/lex_compat.rb#377
-  def dedent_next; end
-
-  # Returns the value of attribute embexpr_balance.
-  #
-  # source://prism//lib/prism/lex_compat.rb#377
-  def embexpr_balance; end
-
-  # source://prism//lib/prism/lex_compat.rb#427
-  def to_a; end
-
-  # Returns the value of attribute tokens.
-  #
-  # source://prism//lib/prism/lex_compat.rb#377
-  def tokens; end
-end
-
-# source://prism//lib/prism/lex_compat.rb#375
-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//lib/prism/lex_compat.rb#296
-class Prism::LexCompat::Heredoc::PlainHeredoc
-  # @return [PlainHeredoc] a new instance of PlainHeredoc
-  #
-  # source://prism//lib/prism/lex_compat.rb#299
-  def initialize; end
-
-  # source://prism//lib/prism/lex_compat.rb#303
-  def <<(token); end
-
-  # source://prism//lib/prism/lex_compat.rb#307
-  def to_a; end
-
-  # source://prism//lib/prism/lex_compat.rb#297
-  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//lib/prism/lex_compat.rb#248
-class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
-  # source://prism//lib/prism/lex_compat.rb#249
-  def ==(other); end
-end
-
-# Tokens where state should be ignored
-# used for :on_comment, :on_heredoc_end, :on_embexpr_end
-#
-# source://prism//lib/prism/lex_compat.rb#238
-class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
-  # source://prism//lib/prism/lex_compat.rb#239
-  def ==(other); end
-end
-
-# Ignored newlines can occasionally have a LABEL state attached to them, so
-# we compare the state differently here.
-#
-# source://prism//lib/prism/lex_compat.rb#259
-class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
-  # source://prism//lib/prism/lex_compat.rb#260
-  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//lib/prism/lex_compat.rb#279
-class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
-  # source://prism//lib/prism/lex_compat.rb#280
-  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//lib/prism/lex_compat.rb#33
-Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
-
-# A result class specialized for holding tokens produced by the lexer.
-#
-# source://prism//lib/prism/lex_compat.rb#14
-class Prism::LexCompat::Result < ::Prism::Result
-  # Create a new lex compat result object with the given values.
-  #
-  # @return [Result] a new instance of Result
-  #
-  # source://prism//lib/prism/lex_compat.rb#19
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  # Implement the hash pattern matching interface for Result.
-  #
-  # source://prism//lib/prism/lex_compat.rb#25
-  def deconstruct_keys(keys); end
-
-  # The list of tokens that were produced by the lexer.
-  #
-  # source://prism//lib/prism/lex_compat.rb#16
-  def value; end
-end
-
-# 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//lib/prism/lex_compat.rb#204
-class Prism::LexCompat::Token < ::SimpleDelegator
-  # The type of the token.
-  #
-  # source://prism//lib/prism/lex_compat.rb#213
-  def event; end
-
-  # The location of the token in the source.
-  #
-  # source://prism//lib/prism/lex_compat.rb#208
-  def location; end
-
-  # The state of the lexer when this token was produced.
-  #
-  # source://prism//lib/prism/lex_compat.rb#223
-  def state; end
-
-  # The slice of the source that this token represents.
-  #
-  # source://prism//lib/prism/lex_compat.rb#218
-  def value; end
-end
-
-# This is a result specific to the `lex` and `lex_file` methods.
-#
-# source://prism//lib/prism/parse_result.rb#610
-class Prism::LexResult < ::Prism::Result
-  # Create a new lex result object with the given values.
-  #
-  # @return [LexResult] a new instance of LexResult
-  #
-  # source://prism//lib/prism/parse_result.rb#615
-  sig do
-    params(
-      value: T::Array[T.untyped],
-      comments: T::Array[Prism::Comment],
-      magic_comments: T::Array[Prism::MagicComment],
-      data_loc: T.nilable(Prism::Location),
-      errors: T::Array[Prism::ParseError],
-      warnings: T::Array[Prism::ParseWarning],
-      source: Prism::Source
-    ).void
-  end
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  # Implement the hash pattern matching interface for LexResult.
-  #
-  # source://prism//lib/prism/parse_result.rb#621
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The list of tokens that were parsed from the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#612
-  sig { returns(T::Array[T.untyped]) }
-  def value; end
-end
-
-# This is a class that wraps the Ripper lexer to produce almost exactly the
-# same tokens.
-#
-# source://prism//lib/prism/lex_compat.rb#872
-class Prism::LexRipper
-  # @return [LexRipper] a new instance of LexRipper
-  #
-  # source://prism//lib/prism/lex_compat.rb#875
-  def initialize(source); end
-
-  # source://prism//lib/prism/lex_compat.rb#879
-  def result; end
-
-  # source://prism//lib/prism/lex_compat.rb#873
-  def source; end
-
-  private
-
-  # source://prism//lib/prism/lex_compat.rb#913
-  def lex(source); end
-end
-
-# Represents the use of the `&&=` operator for assignment to a local variable.
-#
-#     target &&= value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#11943
-class Prism::LocalVariableAndWriteNode < ::Prism::Node
-  # def initialize: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
-  #
-  # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#11945
-  sig do
-    params(
-      source: Prism::Source,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name_loc, operator_loc, value, name, depth, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12051
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#11956
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11961
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#11971
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#11966
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableAndWriteNode
-  #
-  # source://prism//lib/prism/node.rb#11976
-  sig do
-    params(
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).returns(Prism::LocalVariableAndWriteNode)
-  end
-  def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#11961
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#11984
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader depth: Integer
-  #
-  # source://prism//lib/prism/node.rb#12009
-  sig { returns(Integer) }
-  def depth; end
-
-  # source://prism//lib/prism/desugar_compiler.rb#199
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12017
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#12006
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11989
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12012
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#11996
-  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//lib/prism/node.rb#12035
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#12003
-  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//lib/prism/node.rb#12045
-    def type; end
-  end
-end
-
-# Represents assigning to a local variable using an operator that isn't `=`.
-#
-#     target += value
-#     ^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#12065
-class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
-  # def initialize: (Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth, Location location) -> void
-  #
-  # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12067
-  sig do
-    params(
-      source: Prism::Source,
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      binary_operator: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12172
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12079
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader binary_operator: Symbol
-  #
-  # source://prism//lib/prism/node.rb#12132
-  sig { returns(Symbol) }
-  def binary_operator; end
-
-  # attr_reader binary_operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12119
-  sig { returns(Prism::Location) }
-  def binary_operator_loc; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12084
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12094
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12089
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12099
-  sig do
-    params(
-      name_loc: Prism::Location,
-      binary_operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      binary_operator: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).returns(Prism::LocalVariableOperatorWriteNode)
-  end
-  def copy(name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12084
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12107
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader depth: Integer
-  #
-  # source://prism//lib/prism/node.rb#12135
-  sig { returns(Integer) }
-  def depth; end
-
-  # source://prism//lib/prism/desugar_compiler.rb#211
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12138
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#12129
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12112
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # Returns the binary operator used to modify the receiver. This method is
-  # deprecated in favor of #binary_operator.
-  #
-  # source://prism//lib/prism/node_ext.rb#435
-  def operator; end
-
-  # Returns the location of the binary operator used to modify the receiver.
-  # This method is deprecated in favor of #binary_operator_loc.
-  #
-  # source://prism//lib/prism/node_ext.rb#442
-  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//lib/prism/node.rb#12156
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#12126
-  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//lib/prism/node.rb#12166
-    def type; end
-  end
-end
-
-# Represents the use of the `||=` operator for assignment to a local variable.
-#
-#     target ||= value
-#     ^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#12187
-class Prism::LocalVariableOrWriteNode < ::Prism::Node
-  # def initialize: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
-  #
-  # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12189
-  sig do
-    params(
-      source: Prism::Source,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name_loc, operator_loc, value, name, depth, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12295
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12200
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12205
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12215
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12210
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOrWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12220
-  sig do
-    params(
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      name: Symbol,
-      depth: Integer,
-      location: Prism::Location
-    ).returns(Prism::LocalVariableOrWriteNode)
-  end
-  def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12205
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12228
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader depth: Integer
-  #
-  # source://prism//lib/prism/node.rb#12253
-  sig { returns(Integer) }
-  def depth; end
-
-  # source://prism//lib/prism/desugar_compiler.rb#205
-  def desugar; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12261
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#12250
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12233
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12256
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12240
-  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//lib/prism/node.rb#12279
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#12247
-  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//lib/prism/node.rb#12289
-    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//lib/prism/node.rb#12309
-class Prism::LocalVariableReadNode < ::Prism::Node
-  # def initialize: (Symbol name, Integer depth, Location location) -> void
-  #
-  # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#12311
-  sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void }
-  def initialize(source, name, depth, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12406
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12319
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12324
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12334
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12329
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableReadNode
-  #
-  # source://prism//lib/prism/node.rb#12339
-  sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableReadNode) }
-  def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12324
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12347
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  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//lib/prism/node.rb#12369
-  sig { returns(Integer) }
-  def depth; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12372
-  sig { override.returns(String) }
-  def inspect; 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`
-  #
-  # source://prism//lib/prism/node.rb#12360
-  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//lib/prism/node.rb#12390
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#12400
-    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//lib/prism/node.rb#12417
-class Prism::LocalVariableTargetNode < ::Prism::Node
-  # def initialize: (Symbol name, Integer depth, Location location) -> void
-  #
-  # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#12419
-  sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void }
-  def initialize(source, name, depth, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12500
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12427
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12432
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12442
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12437
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableTargetNode
-  #
-  # source://prism//lib/prism/node.rb#12447
-  sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableTargetNode) }
-  def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12432
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12455
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader depth: Integer
-  #
-  # source://prism//lib/prism/node.rb#12463
-  sig { returns(Integer) }
-  def depth; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12466
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#12460
-  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//lib/prism/node.rb#12484
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#12494
-    def type; end
-  end
-end
-
-# Represents writing to a local variable.
-#
-#     foo = 1
-#     ^^^^^^^
-#
-# source://prism//lib/prism/node.rb#12511
-class Prism::LocalVariableWriteNode < ::Prism::Node
-  # def initialize: (Symbol name, Integer depth, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
-  #
-  # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12513
-  sig do
-    params(
-      source: Prism::Source,
-      name: Symbol,
-      depth: Integer,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, name, depth, name_loc, value, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12645
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12524
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12529
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12539
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12534
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> LocalVariableWriteNode
-  #
-  # source://prism//lib/prism/node.rb#12544
-  sig do
-    params(
-      name: Symbol,
-      depth: Integer,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::LocalVariableWriteNode)
-  end
-  def copy(name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12529
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12552
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The number of semantic scopes we have to traverse to find the declaration of this variable.
-  #
-  #     foo = 1         # depth 0
-  #
-  #     tap { foo = 1 } # 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//lib/prism/node.rb#12570
-  sig { returns(Integer) }
-  def depth; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12611
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
-  #
-  #     foo = :bar # name `:foo`
-  #
-  #     abc = 123  # name `:abc`
-  #
-  # source://prism//lib/prism/node.rb#12561
-  sig { returns(Symbol) }
-  def name; end
-
-  # The location of the variable name.
-  #
-  #     foo = :bar
-  #     ^^^
-  #
-  # source://prism//lib/prism/node.rb#12576
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12606
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `=` operator.
-  #
-  #     x = :y
-  #       ^
-  #
-  # source://prism//lib/prism/node.rb#12599
-  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//lib/prism/node.rb#12629
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     foo = :bar
-  #           ^^^^
-  #
-  #     abc = 1234
-  #           ^^^^
-  #
-  # Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
-  #
-  #     foo = foo
-  #
-  # source://prism//lib/prism/node.rb#12593
-  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//lib/prism/node.rb#12639
-    def type; end
-  end
-end
-
-# This represents a location in the source.
-#
-# source://prism//lib/prism/parse_result.rb#156
-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//lib/prism/parse_result.rb#171
-  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
-  def initialize(source, start_offset, length); end
-
-  # Returns true if the given other location is equal to this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#335
-  sig { params(other: T.untyped).returns(T::Boolean) }
-  def ==(other); end
-
-  # Join this location with the first occurrence of the string in the source
-  # that occurs after this location on the same line, and return the new
-  # location. This will raise an error if the string does not exist.
-  #
-  # source://prism//lib/prism/parse_result.rb#354
-  sig { params(string: String).returns(Prism::Location) }
-  def adjoin(string); end
-
-  # Returns a new location that is the result of chopping off the last byte.
-  #
-  # source://prism//lib/prism/parse_result.rb#217
-  sig { returns(Prism::Location) }
-  def chop; end
-
-  # Returns all comments that are associated with this location (both leading
-  # and trailing comments).
-  #
-  # source://prism//lib/prism/parse_result.rb#207
-  sig { returns(T::Array[Prism::Comment]) }
-  def comments; end
-
-  # Create a new location object with the given options.
-  #
-  # source://prism//lib/prism/parse_result.rb#212
-  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
-  def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
-
-  # Implement the hash pattern matching interface for Location.
-  #
-  # source://prism//lib/prism/parse_result.rb#325
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The column number in characters where this location ends from the start of
-  # the line.
-  #
-  # source://prism//lib/prism/parse_result.rb#314
-  sig { returns(Integer) }
-  def end_character_column; end
-
-  # The character offset from the beginning of the source where this location
-  # ends.
-  #
-  # source://prism//lib/prism/parse_result.rb#263
-  sig { returns(Integer) }
-  def end_character_offset; end
-
-  # The column number in code units of the given encoding where this location
-  # ends from the start of the line.
-  #
-  # source://prism//lib/prism/parse_result.rb#320
-  sig { params(encoding: Encoding).returns(Integer) }
-  def end_code_units_column(encoding = T.unsafe(nil)); end
-
-  # The offset from the start of the file in code units of the given encoding.
-  #
-  # source://prism//lib/prism/parse_result.rb#268
-  sig { params(encoding: Encoding).returns(Integer) }
-  def end_code_units_offset(encoding = T.unsafe(nil)); end
-
-  # The column number in bytes where this location ends from the start of the
-  # line.
-  #
-  # source://prism//lib/prism/parse_result.rb#308
-  sig { returns(Integer) }
-  def end_column; end
-
-  # The line number where this location ends.
-  #
-  # source://prism//lib/prism/parse_result.rb#284
-  sig { returns(Integer) }
-  def end_line; end
-
-  # The byte offset from the beginning of the source where this location ends.
-  #
-  # source://prism//lib/prism/parse_result.rb#257
-  sig { returns(Integer) }
-  def end_offset; end
-
-  # Returns a string representation of this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#222
-  sig { returns(String) }
-  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//lib/prism/parse_result.rb#344
-  sig { params(other: Prism::Location).returns(Prism::Location) }
-  def join(other); end
-
-  # Attach a comment to the leading comments of this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#190
-  sig { params(comment: Prism::Comment).void }
-  def leading_comment(comment); end
-
-  # These are the comments that are associated with this location that exist
-  # before the start of this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#185
-  sig { returns(T::Array[Prism::Comment]) }
-  def leading_comments; end
-
-  # The length of this location in bytes.
-  #
-  # source://prism//lib/prism/parse_result.rb#167
-  sig { returns(Integer) }
-  def length; end
-
-  # Implement the pretty print interface for Location.
-  #
-  # source://prism//lib/prism/parse_result.rb#330
-  sig { params(q: T.untyped).void }
-  def pretty_print(q); end
-
-  # The source code that this location represents.
-  #
-  # source://prism//lib/prism/parse_result.rb#232
-  sig { returns(String) }
-  def slice; end
-
-  # The source code that this location represents starting from the beginning
-  # of the line that this location starts on to the end of the line that this
-  # location ends on.
-  #
-  # source://prism//lib/prism/parse_result.rb#239
-  def slice_lines; end
-
-  # Returns all of the lines of the source code associated with this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#227
-  sig { returns(T::Array[String]) }
-  def source_lines; end
-
-  # The column number in characters where this location ends from the start of
-  # the line.
-  #
-  # source://prism//lib/prism/parse_result.rb#296
-  sig { returns(Integer) }
-  def start_character_column; end
-
-  # The character offset from the beginning of the source where this location
-  # starts.
-  #
-  # source://prism//lib/prism/parse_result.rb#247
-  sig { returns(Integer) }
-  def start_character_offset; end
-
-  # The column number in code units of the given encoding where this location
-  # starts from the start of the line.
-  #
-  # source://prism//lib/prism/parse_result.rb#302
-  sig { params(encoding: Encoding).returns(Integer) }
-  def start_code_units_column(encoding = T.unsafe(nil)); end
-
-  # The offset from the start of the file in code units of the given encoding.
-  #
-  # source://prism//lib/prism/parse_result.rb#252
-  sig { params(encoding: Encoding).returns(Integer) }
-  def start_code_units_offset(encoding = T.unsafe(nil)); end
-
-  # The column number in bytes where this location starts from the start of
-  # the line.
-  #
-  # source://prism//lib/prism/parse_result.rb#290
-  sig { returns(Integer) }
-  def start_column; end
-
-  # The line number where this location starts.
-  #
-  # source://prism//lib/prism/parse_result.rb#273
-  sig { returns(Integer) }
-  def start_line; end
-
-  # The content of the line where this location starts before this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#278
-  sig { returns(String) }
-  def start_line_slice; end
-
-  # The byte offset from the beginning of the source where this location
-  # starts.
-  #
-  # source://prism//lib/prism/parse_result.rb#164
-  sig { returns(Integer) }
-  def start_offset; end
-
-  # Attach a comment to the trailing comments of this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#201
-  sig { params(comment: Prism::Comment).void }
-  def trailing_comment(comment); end
-
-  # These are the comments that are associated with this location that exist
-  # after the end of this location.
-  #
-  # source://prism//lib/prism/parse_result.rb#196
-  sig { returns(T::Array[Prism::Comment]) }
-  def trailing_comments; end
-
-  protected
-
-  # A Source object that is used to determine more information from the given
-  # offset and length.
-  #
-  # source://prism//lib/prism/parse_result.rb#159
-  sig { returns(Prism::Source) }
-  def source; end
-end
-
-# Flags for while and until loop nodes.
-#
-# source://prism//lib/prism/node.rb#19196
-module Prism::LoopFlags; end
-
-# a loop after a begin statement, so the body is executed first before the condition
-#
-# source://prism//lib/prism/node.rb#19198
-Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer)
-
-# This represents a magic comment that was encountered during parsing.
-#
-# source://prism//lib/prism/parse_result.rb#416
-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//lib/prism/parse_result.rb#424
-  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
-  def initialize(key_loc, value_loc); end
-
-  # Implement the hash pattern matching interface for MagicComment.
-  #
-  # source://prism//lib/prism/parse_result.rb#440
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Returns a string representation of this magic comment.
-  #
-  # source://prism//lib/prism/parse_result.rb#445
-  sig { returns(String) }
-  def inspect; end
-
-  # Returns the key of the magic comment by slicing it from the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#430
-  sig { returns(String) }
-  def key; end
-
-  # A Location object representing the location of the key in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#418
-  sig { returns(Prism::Location) }
-  def key_loc; end
-
-  # Returns the value of the magic comment by slicing it from the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#435
-  sig { returns(String) }
-  def value; end
-
-  # A Location object representing the location of the value in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#421
-  sig { returns(Prism::Location) }
-  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//lib/prism/node.rb#12659
-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//lib/prism/node.rb#12661
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12837
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12672
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def ascii_8bit?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12758
-  sig { returns(T::Boolean) }
-  def ascii_8bit?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12677
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12798
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12723
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12687
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12682
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def content: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12793
-  sig { returns(String) }
-  def content; end
-
-  # attr_reader content_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12716
-  sig { returns(Prism::Location) }
-  def content_loc; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> MatchLastLineNode
-  #
-  # source://prism//lib/prism/node.rb#12692
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).returns(Prism::MatchLastLineNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12677
-  sig { override.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//lib/prism/node.rb#12700
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def euc_jp?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12753
-  sig { returns(T::Boolean) }
-  def euc_jp?; end
-
-  # def extended?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12738
-  sig { returns(T::Boolean) }
-  def extended?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12778
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_us_ascii_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12783
-  sig { returns(T::Boolean) }
-  def forced_us_ascii_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12773
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def ignore_case?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12733
-  sig { returns(T::Boolean) }
-  def ignore_case?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12803
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def multi_line?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12743
-  sig { returns(T::Boolean) }
-  def multi_line?; end
-
-  # def once?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12748
-  sig { returns(T::Boolean) }
-  def once?; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12788
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12709
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  sig { returns(Integer) }
-  def options; 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//lib/prism/node.rb#12821
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader unescaped: String
-  #
-  # source://prism//lib/prism/node.rb#12730
-  sig { returns(String) }
-  def unescaped; end
-
-  # def utf_8?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12768
-  sig { returns(T::Boolean) }
-  def utf_8?; end
-
-  # def windows_31j?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#12763
-  sig { returns(T::Boolean) }
-  def windows_31j?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#12705
-  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//lib/prism/node.rb#12831
-    def type; end
-  end
-end
-
-# Represents the use of the modifier `in` operator.
-#
-#     foo in bar
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#12851
-class Prism::MatchPredicateNode < ::Prism::Node
-  # def initialize: (Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
-  #
-  # @return [MatchPredicateNode] a new instance of MatchPredicateNode
-  #
-  # source://prism//lib/prism/node.rb#12853
-  sig do
-    params(
-      source: Prism::Source,
-      value: Prism::Node,
-      pattern: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, value, pattern, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#12947
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12862
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12867
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12877
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12872
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchPredicateNode
-  #
-  # source://prism//lib/prism/node.rb#12882
-  sig do
-    params(
-      value: Prism::Node,
-      pattern: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::MatchPredicateNode)
-  end
-  def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12867
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12890
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#12913
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#12908
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#12901
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader pattern: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#12898
-  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//lib/prism/node.rb#12931
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#12895
-  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//lib/prism/node.rb#12941
-    def type; end
-  end
-end
-
-# Represents the use of the `=>` operator.
-#
-#     foo => bar
-#     ^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#12959
-class Prism::MatchRequiredNode < ::Prism::Node
-  # def initialize: (Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
-  #
-  # @return [MatchRequiredNode] a new instance of MatchRequiredNode
-  #
-  # source://prism//lib/prism/node.rb#12961
-  sig do
-    params(
-      source: Prism::Source,
-      value: Prism::Node,
-      pattern: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, value, pattern, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13055
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#12970
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12975
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#12985
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#12980
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchRequiredNode
-  #
-  # source://prism//lib/prism/node.rb#12990
-  sig do
-    params(
-      value: Prism::Node,
-      pattern: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::MatchRequiredNode)
-  end
-  def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#12975
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#12998
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13021
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13016
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13009
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader pattern: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#13006
-  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//lib/prism/node.rb#13039
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#13003
-  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//lib/prism/node.rb#13049
-    def type; end
-  end
-end
-
-# Represents writing local variables using a regular expression match with named capture groups.
-#
-#     /(?<foo>bar)/ =~ baz
-#     ^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#13067
-class Prism::MatchWriteNode < ::Prism::Node
-  # def initialize: (CallNode call, Array[LocalVariableTargetNode] targets, Location location) -> void
-  #
-  # @return [MatchWriteNode] a new instance of MatchWriteNode
-  #
-  # source://prism//lib/prism/node.rb#13069
-  sig do
-    params(
-      source: Prism::Source,
-      call: Prism::CallNode,
-      targets: T::Array[Prism::LocalVariableTargetNode],
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, call, targets, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13150
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13077
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader call: CallNode
-  #
-  # source://prism//lib/prism/node.rb#13110
-  sig { returns(Prism::CallNode) }
-  def call; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13082
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13092
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13087
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?call: CallNode, ?targets: Array[LocalVariableTargetNode], ?location: Location) -> MatchWriteNode
-  #
-  # source://prism//lib/prism/node.rb#13097
-  sig do
-    params(
-      call: Prism::CallNode,
-      targets: T::Array[Prism::LocalVariableTargetNode],
-      location: Prism::Location
-    ).returns(Prism::MatchWriteNode)
-  end
-  def copy(call: T.unsafe(nil), targets: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13082
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { call: CallNode, targets: Array[LocalVariableTargetNode], location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13105
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13116
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader targets: Array[LocalVariableTargetNode]
-  #
-  # source://prism//lib/prism/node.rb#13113
-  sig { returns(T::Array[Prism::LocalVariableTargetNode]) }
-  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//lib/prism/node.rb#13134
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13144
-    def type; end
-  end
-end
-
-# Represents a node that is missing from the source and results in a syntax error.
-#
-# source://prism//lib/prism/node.rb#13159
-class Prism::MissingNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [MissingNode] a new instance of MissingNode
-  #
-  # source://prism//lib/prism/node.rb#13161
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13234
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13167
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13172
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13182
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13177
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> MissingNode
-  #
-  # source://prism//lib/prism/node.rb#13187
-  sig { params(location: Prism::Location).returns(Prism::MissingNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13172
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13195
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13200
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#13218
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13228
-    def type; end
-  end
-end
-
-# Represents a module declaration involving the `module` keyword.
-#
-#     module Foo end
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#13243
-class Prism::ModuleNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, Location module_keyword_loc, Prism::node constant_path, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
-  #
-  # @return [ModuleNode] a new instance of ModuleNode
-  #
-  # source://prism//lib/prism/node.rb#13245
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      module_keyword_loc: Prism::Location,
-      constant_path: Prism::Node,
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      name: Symbol,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13363
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13257
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#13306
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13262
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13275
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13267
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader constant_path: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#13303
-  sig { returns(Prism::Node) }
-  def constant_path; end
-
-  # def copy: (?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ModuleNode
-  #
-  # source://prism//lib/prism/node.rb#13280
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      module_keyword_loc: Prism::Location,
-      constant_path: Prism::Node,
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      name: Symbol,
-      location: Prism::Location
-    ).returns(Prism::ModuleNode)
-  end
-  def copy(locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13262
-  sig { override.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: Prism::node, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13288
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13324
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13309
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13329
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#13293
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # def module_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13319
-  sig { returns(String) }
-  def module_keyword; end
-
-  # attr_reader module_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13296
-  sig { returns(Prism::Location) }
-  def module_keyword_loc; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#13316
-  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//lib/prism/node.rb#13347
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13357
-    def type; end
-  end
-end
-
-# Represents a multi-target expression.
-#
-#     a, (b, c) = 1, 2, 3
-#        ^^^^^^
-#
-# source://prism//lib/prism/node.rb#13379
-class Prism::MultiTargetNode < ::Prism::Node
-  # def initialize: (Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc, Location location) -> void
-  #
-  # @return [MultiTargetNode] a new instance of MultiTargetNode
-  #
-  # source://prism//lib/prism/node.rb#13381
-  sig do
-    params(
-      source: Prism::Source,
-      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
-      rest: T.nilable(Prism::Node),
-      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)],
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13508
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13392
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13397
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13411
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13402
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?location: Location) -> MultiTargetNode
-  #
-  # source://prism//lib/prism/node.rb#13416
-  sig do
-    params(
-      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
-      rest: T.nilable(Prism::Node),
-      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)],
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::MultiTargetNode)
-  end
-  def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13397
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13424
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13474
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode]
-  #
-  # source://prism//lib/prism/node.rb#13429
-  sig do
-    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
-  end
-  def lefts; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#13464
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#13438
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # attr_reader rest: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#13432
-  sig { returns(T.nilable(Prism::Node)) }
-  def rest; end
-
-  # attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode]
-  #
-  # source://prism//lib/prism/node.rb#13435
-  sig do
-    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)])
-  end
-  def rights; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#13469
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#13451
-  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//lib/prism/node.rb#13492
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13502
-    def type; end
-  end
-end
-
-# Represents a write to a multi-target expression.
-#
-#     a, b, c = 1, 2, 3
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#13524
-class Prism::MultiWriteNode < ::Prism::Node
-  # def initialize: (Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [MultiWriteNode] a new instance of MultiWriteNode
-  #
-  # source://prism//lib/prism/node.rb#13526
-  sig do
-    params(
-      source: Prism::Source,
-      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
-      rest: T.nilable(Prism::Node),
-      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13671
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13539
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13544
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13559
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13549
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> MultiWriteNode
-  #
-  # source://prism//lib/prism/node.rb#13564
-  sig do
-    params(
-      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
-      rest: T.nilable(Prism::Node),
-      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
-      lparen_loc: T.nilable(Prism::Location),
-      rparen_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::MultiWriteNode)
-  end
-  def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13544
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13572
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13637
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
-  #
-  # source://prism//lib/prism/node.rb#13577
-  sig do
-    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)])
-  end
-  def lefts; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#13622
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#13586
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13632
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13612
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # attr_reader rest: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#13580
-  sig { returns(T.nilable(Prism::Node)) }
-  def rest; end
-
-  # attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
-  #
-  # source://prism//lib/prism/node.rb#13583
-  sig do
-    returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)])
-  end
-  def rights; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#13627
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#13599
-  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//lib/prism/node.rb#13655
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#13619
-  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//lib/prism/node.rb#13665
-    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//lib/prism/mutation_compiler.rb#13
-class Prism::MutationCompiler < ::Prism::Compiler
-  # Copy a AliasGlobalVariableNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#15
-  def visit_alias_global_variable_node(node); end
-
-  # Copy a AliasMethodNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#20
-  def visit_alias_method_node(node); end
-
-  # Copy a AlternationPatternNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#25
-  def visit_alternation_pattern_node(node); end
-
-  # Copy a AndNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#30
-  def visit_and_node(node); end
-
-  # Copy a ArgumentsNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#35
-  def visit_arguments_node(node); end
-
-  # Copy a ArrayNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#40
-  def visit_array_node(node); end
-
-  # Copy a ArrayPatternNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#45
-  def visit_array_pattern_node(node); end
-
-  # Copy a AssocNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#50
-  def visit_assoc_node(node); end
-
-  # Copy a AssocSplatNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#55
-  def visit_assoc_splat_node(node); end
-
-  # Copy a BackReferenceReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#60
-  def visit_back_reference_read_node(node); end
-
-  # Copy a BeginNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#65
-  def visit_begin_node(node); end
-
-  # Copy a BlockArgumentNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#70
-  def visit_block_argument_node(node); end
-
-  # Copy a BlockLocalVariableNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#75
-  def visit_block_local_variable_node(node); end
-
-  # Copy a BlockNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#80
-  def visit_block_node(node); end
-
-  # Copy a BlockParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#85
-  def visit_block_parameter_node(node); end
-
-  # Copy a BlockParametersNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#90
-  def visit_block_parameters_node(node); end
-
-  # Copy a BreakNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#95
-  def visit_break_node(node); end
-
-  # Copy a CallAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#100
-  def visit_call_and_write_node(node); end
-
-  # Copy a CallNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#105
-  def visit_call_node(node); end
-
-  # Copy a CallOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#110
-  def visit_call_operator_write_node(node); end
-
-  # Copy a CallOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#115
-  def visit_call_or_write_node(node); end
-
-  # Copy a CallTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#120
-  def visit_call_target_node(node); end
-
-  # Copy a CapturePatternNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#125
-  def visit_capture_pattern_node(node); end
-
-  # Copy a CaseMatchNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#130
-  def visit_case_match_node(node); end
-
-  # Copy a CaseNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#135
-  def visit_case_node(node); end
-
-  # Copy a ClassNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#140
-  def visit_class_node(node); end
-
-  # Copy a ClassVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#145
-  def visit_class_variable_and_write_node(node); end
-
-  # Copy a ClassVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#150
-  def visit_class_variable_operator_write_node(node); end
-
-  # Copy a ClassVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#155
-  def visit_class_variable_or_write_node(node); end
-
-  # Copy a ClassVariableReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#160
-  def visit_class_variable_read_node(node); end
-
-  # Copy a ClassVariableTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#165
-  def visit_class_variable_target_node(node); end
-
-  # Copy a ClassVariableWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#170
-  def visit_class_variable_write_node(node); end
-
-  # Copy a ConstantAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#175
-  def visit_constant_and_write_node(node); end
-
-  # Copy a ConstantOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#180
-  def visit_constant_operator_write_node(node); end
-
-  # Copy a ConstantOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#185
-  def visit_constant_or_write_node(node); end
-
-  # Copy a ConstantPathAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#190
-  def visit_constant_path_and_write_node(node); end
-
-  # Copy a ConstantPathNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#195
-  def visit_constant_path_node(node); end
-
-  # Copy a ConstantPathOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#200
-  def visit_constant_path_operator_write_node(node); end
-
-  # Copy a ConstantPathOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#205
-  def visit_constant_path_or_write_node(node); end
-
-  # Copy a ConstantPathTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#210
-  def visit_constant_path_target_node(node); end
-
-  # Copy a ConstantPathWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#215
-  def visit_constant_path_write_node(node); end
-
-  # Copy a ConstantReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#220
-  def visit_constant_read_node(node); end
-
-  # Copy a ConstantTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#225
-  def visit_constant_target_node(node); end
-
-  # Copy a ConstantWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#230
-  def visit_constant_write_node(node); end
-
-  # Copy a DefNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#235
-  def visit_def_node(node); end
-
-  # Copy a DefinedNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#240
-  def visit_defined_node(node); end
-
-  # Copy a ElseNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#245
-  def visit_else_node(node); end
-
-  # Copy a EmbeddedStatementsNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#250
-  def visit_embedded_statements_node(node); end
-
-  # Copy a EmbeddedVariableNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#255
-  def visit_embedded_variable_node(node); end
-
-  # Copy a EnsureNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#260
-  def visit_ensure_node(node); end
-
-  # Copy a FalseNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#265
-  def visit_false_node(node); end
-
-  # Copy a FindPatternNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#270
-  def visit_find_pattern_node(node); end
-
-  # Copy a FlipFlopNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#275
-  def visit_flip_flop_node(node); end
-
-  # Copy a FloatNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#280
-  def visit_float_node(node); end
-
-  # Copy a ForNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#285
-  def visit_for_node(node); end
-
-  # Copy a ForwardingArgumentsNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#290
-  def visit_forwarding_arguments_node(node); end
-
-  # Copy a ForwardingParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#295
-  def visit_forwarding_parameter_node(node); end
-
-  # Copy a ForwardingSuperNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#300
-  def visit_forwarding_super_node(node); end
-
-  # Copy a GlobalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#305
-  def visit_global_variable_and_write_node(node); end
-
-  # Copy a GlobalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#310
-  def visit_global_variable_operator_write_node(node); end
-
-  # Copy a GlobalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#315
-  def visit_global_variable_or_write_node(node); end
-
-  # Copy a GlobalVariableReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#320
-  def visit_global_variable_read_node(node); end
-
-  # Copy a GlobalVariableTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#325
-  def visit_global_variable_target_node(node); end
-
-  # Copy a GlobalVariableWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#330
-  def visit_global_variable_write_node(node); end
-
-  # Copy a HashNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#335
-  def visit_hash_node(node); end
-
-  # Copy a HashPatternNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#340
-  def visit_hash_pattern_node(node); end
-
-  # Copy a IfNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#345
-  def visit_if_node(node); end
-
-  # Copy a ImaginaryNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#350
-  def visit_imaginary_node(node); end
-
-  # Copy a ImplicitNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#355
-  def visit_implicit_node(node); end
-
-  # Copy a ImplicitRestNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#360
-  def visit_implicit_rest_node(node); end
-
-  # Copy a InNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#365
-  def visit_in_node(node); end
-
-  # Copy a IndexAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#370
-  def visit_index_and_write_node(node); end
-
-  # Copy a IndexOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#375
-  def visit_index_operator_write_node(node); end
-
-  # Copy a IndexOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#380
-  def visit_index_or_write_node(node); end
-
-  # Copy a IndexTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#385
-  def visit_index_target_node(node); end
-
-  # Copy a InstanceVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#390
-  def visit_instance_variable_and_write_node(node); end
-
-  # Copy a InstanceVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#395
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Copy a InstanceVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#400
-  def visit_instance_variable_or_write_node(node); end
-
-  # Copy a InstanceVariableReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#405
-  def visit_instance_variable_read_node(node); end
-
-  # Copy a InstanceVariableTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#410
-  def visit_instance_variable_target_node(node); end
-
-  # Copy a InstanceVariableWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#415
-  def visit_instance_variable_write_node(node); end
-
-  # Copy a IntegerNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#420
-  def visit_integer_node(node); end
-
-  # Copy a InterpolatedMatchLastLineNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#425
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Copy a InterpolatedRegularExpressionNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#430
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Copy a InterpolatedStringNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#435
-  def visit_interpolated_string_node(node); end
-
-  # Copy a InterpolatedSymbolNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#440
-  def visit_interpolated_symbol_node(node); end
-
-  # Copy a InterpolatedXStringNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#445
-  def visit_interpolated_x_string_node(node); end
-
-  # Copy a ItLocalVariableReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#450
-  def visit_it_local_variable_read_node(node); end
-
-  # Copy a ItParametersNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#455
-  def visit_it_parameters_node(node); end
-
-  # Copy a KeywordHashNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#460
-  def visit_keyword_hash_node(node); end
-
-  # Copy a KeywordRestParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#465
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Copy a LambdaNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#470
-  def visit_lambda_node(node); end
-
-  # Copy a LocalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#475
-  def visit_local_variable_and_write_node(node); end
-
-  # Copy a LocalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#480
-  def visit_local_variable_operator_write_node(node); end
-
-  # Copy a LocalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#485
-  def visit_local_variable_or_write_node(node); end
-
-  # Copy a LocalVariableReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#490
-  def visit_local_variable_read_node(node); end
-
-  # Copy a LocalVariableTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#495
-  def visit_local_variable_target_node(node); end
-
-  # Copy a LocalVariableWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#500
-  def visit_local_variable_write_node(node); end
-
-  # Copy a MatchLastLineNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#505
-  def visit_match_last_line_node(node); end
-
-  # Copy a MatchPredicateNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#510
-  def visit_match_predicate_node(node); end
-
-  # Copy a MatchRequiredNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#515
-  def visit_match_required_node(node); end
-
-  # Copy a MatchWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#520
-  def visit_match_write_node(node); end
-
-  # Copy a MissingNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#525
-  def visit_missing_node(node); end
-
-  # Copy a ModuleNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#530
-  def visit_module_node(node); end
-
-  # Copy a MultiTargetNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#535
-  def visit_multi_target_node(node); end
-
-  # Copy a MultiWriteNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#540
-  def visit_multi_write_node(node); end
-
-  # Copy a NextNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#545
-  def visit_next_node(node); end
-
-  # Copy a NilNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#550
-  def visit_nil_node(node); end
-
-  # Copy a NoKeywordsParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#555
-  def visit_no_keywords_parameter_node(node); end
-
-  # Copy a NumberedParametersNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#560
-  def visit_numbered_parameters_node(node); end
-
-  # Copy a NumberedReferenceReadNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#565
-  def visit_numbered_reference_read_node(node); end
-
-  # Copy a OptionalKeywordParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#570
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Copy a OptionalParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#575
-  def visit_optional_parameter_node(node); end
-
-  # Copy a OrNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#580
-  def visit_or_node(node); end
-
-  # Copy a ParametersNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#585
-  def visit_parameters_node(node); end
-
-  # Copy a ParenthesesNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#590
-  def visit_parentheses_node(node); end
-
-  # Copy a PinnedExpressionNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#595
-  def visit_pinned_expression_node(node); end
-
-  # Copy a PinnedVariableNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#600
-  def visit_pinned_variable_node(node); end
-
-  # Copy a PostExecutionNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#605
-  def visit_post_execution_node(node); end
-
-  # Copy a PreExecutionNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#610
-  def visit_pre_execution_node(node); end
-
-  # Copy a ProgramNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#615
-  def visit_program_node(node); end
-
-  # Copy a RangeNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#620
-  def visit_range_node(node); end
-
-  # Copy a RationalNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#625
-  def visit_rational_node(node); end
-
-  # Copy a RedoNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#630
-  def visit_redo_node(node); end
-
-  # Copy a RegularExpressionNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#635
-  def visit_regular_expression_node(node); end
-
-  # Copy a RequiredKeywordParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#640
-  def visit_required_keyword_parameter_node(node); end
-
-  # Copy a RequiredParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#645
-  def visit_required_parameter_node(node); end
-
-  # Copy a RescueModifierNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#650
-  def visit_rescue_modifier_node(node); end
-
-  # Copy a RescueNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#655
-  def visit_rescue_node(node); end
-
-  # Copy a RestParameterNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#660
-  def visit_rest_parameter_node(node); end
-
-  # Copy a RetryNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#665
-  def visit_retry_node(node); end
-
-  # Copy a ReturnNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#670
-  def visit_return_node(node); end
-
-  # Copy a SelfNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#675
-  def visit_self_node(node); end
-
-  # Copy a ShareableConstantNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#680
-  def visit_shareable_constant_node(node); end
-
-  # Copy a SingletonClassNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#685
-  def visit_singleton_class_node(node); end
-
-  # Copy a SourceEncodingNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#690
-  def visit_source_encoding_node(node); end
-
-  # Copy a SourceFileNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#695
-  def visit_source_file_node(node); end
-
-  # Copy a SourceLineNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#700
-  def visit_source_line_node(node); end
-
-  # Copy a SplatNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#705
-  def visit_splat_node(node); end
-
-  # Copy a StatementsNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#710
-  def visit_statements_node(node); end
-
-  # Copy a StringNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#715
-  def visit_string_node(node); end
-
-  # Copy a SuperNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#720
-  def visit_super_node(node); end
-
-  # Copy a SymbolNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#725
-  def visit_symbol_node(node); end
-
-  # Copy a TrueNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#730
-  def visit_true_node(node); end
-
-  # Copy a UndefNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#735
-  def visit_undef_node(node); end
-
-  # Copy a UnlessNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#740
-  def visit_unless_node(node); end
-
-  # Copy a UntilNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#745
-  def visit_until_node(node); end
-
-  # Copy a WhenNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#750
-  def visit_when_node(node); end
-
-  # Copy a WhileNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#755
-  def visit_while_node(node); end
-
-  # Copy a XStringNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#760
-  def visit_x_string_node(node); end
-
-  # Copy a YieldNode node
-  #
-  # source://prism//lib/prism/mutation_compiler.rb#765
-  def visit_yield_node(node); end
-end
-
-# Represents the use of the `next` keyword.
-#
-#     next 1
-#     ^^^^^^
-#
-# source://prism//lib/prism/node.rb#13689
-class Prism::NextNode < ::Prism::Node
-  # def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
-  #
-  # @return [NextNode] a new instance of NextNode
-  #
-  # source://prism//lib/prism/node.rb#13691
-  sig do
-    params(
-      source: Prism::Source,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, arguments, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13783
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13699
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#13734
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13704
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13716
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13709
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> NextNode
-  #
-  # source://prism//lib/prism/node.rb#13721
-  sig do
-    params(
-      arguments: T.nilable(Prism::ArgumentsNode),
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::NextNode)
-  end
-  def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13704
-  sig { override.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//lib/prism/node.rb#13729
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13749
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13744
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13737
-  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//lib/prism/node.rb#13767
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13777
-    def type; end
-  end
-end
-
-# Represents the use of the `nil` keyword.
-#
-#     nil
-#     ^^^
-#
-# source://prism//lib/prism/node.rb#13794
-class Prism::NilNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [NilNode] a new instance of NilNode
-  #
-  # source://prism//lib/prism/node.rb#13796
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13869
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13802
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13807
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13817
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13812
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> NilNode
-  #
-  # source://prism//lib/prism/node.rb#13822
-  sig { params(location: Prism::Location).returns(Prism::NilNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13807
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#13830
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13835
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#13853
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13863
-    def type; end
-  end
-end
-
-# Represents the use of `**nil` inside method arguments.
-#
-#     def a(**nil)
-#           ^^^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#13879
-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//lib/prism/node.rb#13881
-  sig do
-    params(
-      source: Prism::Source,
-      operator_loc: Prism::Location,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, operator_loc, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#13980
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#13889
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13894
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#13904
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#13899
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?operator_loc: Location, ?keyword_loc: Location, ?location: Location) -> NoKeywordsParameterNode
-  #
-  # source://prism//lib/prism/node.rb#13909
-  sig do
-    params(
-      operator_loc: Prism::Location,
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::NoKeywordsParameterNode)
-  end
-  def copy(operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#13894
-  sig { override.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//lib/prism/node.rb#13917
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#13946
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13941
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13929
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#13936
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#13922
-  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//lib/prism/node.rb#13964
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#13974
-    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//lib/prism/node.rb#12
-class Prism::Node
-  abstract!
-
-  # Accepts a visitor and calls back into the specialized visit function.
-  #
-  # @raise [NoMethodError]
-  #
-  # source://prism//lib/prism/node.rb#131
-  sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
-  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//lib/prism/node.rb#137
-  sig { abstract.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//lib/prism/node.rb#151
-  sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  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//lib/prism/node.rb#145
-  sig { abstract.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//lib/prism/node.rb#137
-  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # source://prism//lib/prism/node_ext.rb#7
-  def deprecated(*replacements); end
-
-  # The end offset of the node in the source. This method is effectively a
-  # delegate method to the location object.
-  #
-  # source://prism//lib/prism/node.rb#34
-  sig { returns(Integer) }
-  def end_offset; end
-
-  sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Returns a string representation of the node.
-  #
-  # @raise [NoMethodError]
-  #
-  # source://prism//lib/prism/node.rb#162
-  sig { abstract.returns(String) }
-  def inspect; end
-
-  # A Location instance that represents the location of this node in the
-  # source.
-  #
-  # source://prism//lib/prism/node.rb#19
-  sig { returns(Prism::Location) }
-  def location; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#69
-  def newline!(lines); end
-
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#65
-  def newline?; end
-
-  # Similar to inspect, but respects the current level of indentation given by
-  # the pretty print object.
-  #
-  # source://prism//lib/prism/node.rb#62
-  sig { params(q: T.untyped).void }
-  def pretty_print(q); end
-
-  # Returns all of the lines of the source code associated with this node.
-  # An alias for source_lines, used to mimic the API from
-  # RubyVM::AbstractSyntaxTree to make it easier to migrate.
-  #
-  # source://prism//lib/prism/node.rb#40
-  sig { returns(T::Array[String]) }
-  def script_lines; end
-
-  # Slice the location of the node from the source.
-  #
-  # source://prism//lib/prism/node.rb#49
-  sig { returns(String) }
-  def slice; end
-
-  # Slice the location of the node from the source, starting at the beginning
-  # of the line that the location starts on, ending at the end of the line
-  # that the location ends on.
-  #
-  # source://prism//lib/prism/node.rb#56
-  sig { returns(String) }
-  def slice_lines; end
-
-  # Returns all of the lines of the source code associated with this node.
-  #
-  # source://prism//lib/prism/node.rb#40
-  sig { returns(T::Array[String]) }
-  def source_lines; end
-
-  # The start offset of the node in the source. This method is effectively a
-  # delegate method to the location object.
-  #
-  # source://prism//lib/prism/node.rb#27
-  sig { returns(Integer) }
-  def start_offset; end
-
-  # Convert this node into a graphviz dot graph string.
-  #
-  # source://prism//lib/prism/node.rb#70
-  sig { returns(String) }
-  def to_dot; end
-
-  # Returns a list of nodes that are descendants of this node that contain the
-  # given line and column. This is useful for locating a node that is selected
-  # based on the line and column of the source code.
-  #
-  # Important to note is that the column given to this method should be in
-  # bytes, as opposed to characters or code units.
-  #
-  # source://prism//lib/prism/node.rb#81
-  sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
-  def tunnel(line, column); 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//lib/prism/node.rb#157
-  sig { abstract.returns(Symbol) }
-  def type; end
-
-  private
-
-  # A pointer to the source that this node was created from.
-  #
-  # source://prism//lib/prism/node.rb#14
-  sig { returns(Prism::Source) }
-  def source; end
-
-  class << self
-    # Returns a list of the fields that exist for this node class. Fields
-    # describe the structure of the node. This kind of reflection is useful for
-    # things like recursively visiting each node _and_ field in the tree.
-    #
-    # @raise [NoMethodError]
-    #
-    # source://prism//lib/prism/node.rb#115
-    def fields; end
-
-    # Returns the type of the node as a symbol.
-    #
-    # @raise [NoMethodError]
-    #
-    # source://prism//lib/prism/node.rb#167
-    def type; end
-  end
-end
-
-# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
-#
-#     -> { _1 + _2 }
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#13991
-class Prism::NumberedParametersNode < ::Prism::Node
-  # def initialize: (Integer maximum, Location location) -> void
-  #
-  # @return [NumberedParametersNode] a new instance of NumberedParametersNode
-  #
-  # source://prism//lib/prism/node.rb#13993
-  sig { params(source: Prism::Source, maximum: Integer, location: Prism::Location).void }
-  def initialize(source, maximum, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14070
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14000
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14005
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14015
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14010
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?maximum: Integer, ?location: Location) -> NumberedParametersNode
-  #
-  # source://prism//lib/prism/node.rb#14020
-  sig { params(maximum: Integer, location: Prism::Location).returns(Prism::NumberedParametersNode) }
-  def copy(maximum: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14005
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { maximum: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14028
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14036
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader maximum: Integer
-  #
-  # source://prism//lib/prism/node.rb#14033
-  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//lib/prism/node.rb#14054
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14064
-    def type; end
-  end
-end
-
-# Represents reading a numbered reference to a capture in the previous match.
-#
-#     $1
-#     ^^
-#
-# source://prism//lib/prism/node.rb#14080
-class Prism::NumberedReferenceReadNode < ::Prism::Node
-  # def initialize: (Integer number, Location location) -> void
-  #
-  # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
-  #
-  # source://prism//lib/prism/node.rb#14082
-  sig { params(source: Prism::Source, number: Integer, location: Prism::Location).void }
-  def initialize(source, number, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14165
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14089
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14094
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14104
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14099
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?number: Integer, ?location: Location) -> NumberedReferenceReadNode
-  #
-  # source://prism//lib/prism/node.rb#14109
-  sig { params(number: Integer, location: Prism::Location).returns(Prism::NumberedReferenceReadNode) }
-  def copy(number: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14094
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { number: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14117
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14131
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
-  #
-  #     $1          # number `1`
-  #
-  #     $5432       # number `5432`
-  #
-  #     $4294967296 # number `0`
-  #
-  # source://prism//lib/prism/node.rb#14128
-  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//lib/prism/node.rb#14149
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14159
-    def type; end
-  end
-end
-
-# Represents an optional keyword parameter to a method, block, or lambda definition.
-#
-#     def a(b: 1)
-#           ^^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#14176
-class Prism::OptionalKeywordParameterNode < ::Prism::Node
-  # def initialize: (Integer flags, Symbol name, Location name_loc, Prism::node value, Location location) -> void
-  #
-  # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
-  #
-  # source://prism//lib/prism/node.rb#14178
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14277
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14188
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14193
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14203
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14198
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalKeywordParameterNode
-  #
-  # source://prism//lib/prism/node.rb#14208
-  sig do
-    params(
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::OptionalKeywordParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14193
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, value: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14216
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14243
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#14225
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14228
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#14238
-  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//lib/prism/node.rb#14261
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#14235
-  sig { returns(Prism::Node) }
-  def value; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#14221
-  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//lib/prism/node.rb#14271
-    def type; end
-  end
-end
-
-# Represents an optional parameter to a method, block, or lambda definition.
-#
-#     def a(b = 1)
-#           ^^^^^
-#     end
-#
-# source://prism//lib/prism/node.rb#14291
-class Prism::OptionalParameterNode < ::Prism::Node
-  # def initialize: (Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
-  #
-  # @return [OptionalParameterNode] a new instance of OptionalParameterNode
-  #
-  # source://prism//lib/prism/node.rb#14293
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, operator_loc, value, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14405
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14304
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14309
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14319
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14314
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalParameterNode
-  #
-  # source://prism//lib/prism/node.rb#14324
-  sig do
-    params(
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      value: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::OptionalParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14309
-  sig { override.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: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14332
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14371
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#14341
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14344
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14366
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14351
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#14361
-  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//lib/prism/node.rb#14389
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader value: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#14358
-  sig { returns(Prism::Node) }
-  def value; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#14337
-  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//lib/prism/node.rb#14399
-    def type; end
-  end
-end
-
-# Represents the use of the `||` operator or the `or` keyword.
-#
-#     left or right
-#     ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#14419
-class Prism::OrNode < ::Prism::Node
-  # def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
-  #
-  # @return [OrNode] a new instance of OrNode
-  #
-  # source://prism//lib/prism/node.rb#14421
-  sig do
-    params(
-      source: Prism::Source,
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, left, right, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14530
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14430
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14435
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14445
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14440
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> OrNode
-  #
-  # source://prism//lib/prism/node.rb#14450
-  sig do
-    params(
-      left: Prism::Node,
-      right: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::OrNode)
-  end
-  def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14435
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14458
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14496
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#14469
-  sig { returns(Prism::Node) }
-  def left; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14491
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `or` keyword or the `||` operator.
-  #
-  #     left or right
-  #          ^^
-  #
-  # source://prism//lib/prism/node.rb#14484
-  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//lib/prism/node.rb#14478
-  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//lib/prism/node.rb#14514
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14524
-    def type; end
-  end
-end
-
-# A parser for the pack template language.
-#
-# source://prism//lib/prism/pack.rb#6
-module Prism::Pack
-  class << self
-    def parse(_arg0, _arg1, _arg2); end
-  end
-end
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
-
-# A directive in the pack template language.
-#
-# source://prism//lib/prism/pack.rb#60
-class Prism::Pack::Directive
-  # Initialize a new directive with the given values.
-  #
-  # @return [Directive] a new instance of Directive
-  #
-  # source://prism//lib/prism/pack.rb#89
-  def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
-
-  # Provide a human-readable description of the directive.
-  #
-  # source://prism//lib/prism/pack.rb#131
-  def describe; end
-
-  # The type of endianness of the directive.
-  #
-  # source://prism//lib/prism/pack.rb#77
-  def endian; end
-
-  # The length of this directive (used for integers).
-  #
-  # source://prism//lib/prism/pack.rb#86
-  def length; end
-
-  # The length type of this directive (used for integers).
-  #
-  # source://prism//lib/prism/pack.rb#83
-  def length_type; end
-
-  # The type of signedness of the directive.
-  #
-  # source://prism//lib/prism/pack.rb#74
-  def signed; end
-
-  # The size of the directive.
-  #
-  # source://prism//lib/prism/pack.rb#80
-  def size; end
-
-  # A byteslice of the source string that this directive represents.
-  #
-  # source://prism//lib/prism/pack.rb#68
-  def source; end
-
-  # The type of the directive.
-  #
-  # source://prism//lib/prism/pack.rb#71
-  def type; end
-
-  # A symbol representing whether or not we are packing or unpacking.
-  #
-  # source://prism//lib/prism/pack.rb#65
-  def variant; end
-
-  # A symbol representing the version of Ruby.
-  #
-  # source://prism//lib/prism/pack.rb#62
-  def version; end
-end
-
-# The descriptions of the various types of endianness.
-#
-# source://prism//lib/prism/pack.rb#102
-Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
-
-# The descriptions of the various types of signedness.
-#
-# source://prism//lib/prism/pack.rb#111
-Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
-
-# The descriptions of the various types of sizes.
-#
-# source://prism//lib/prism/pack.rb#118
-Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
-
-# The result of parsing a pack template.
-#
-# source://prism//lib/prism/pack.rb#198
-class Prism::Pack::Format
-  # Create a new Format with the given directives and encoding.
-  #
-  # @return [Format] a new instance of Format
-  #
-  # source://prism//lib/prism/pack.rb#206
-  def initialize(directives, encoding); end
-
-  # Provide a human-readable description of the format.
-  #
-  # source://prism//lib/prism/pack.rb#212
-  def describe; end
-
-  # A list of the directives in the template.
-  #
-  # source://prism//lib/prism/pack.rb#200
-  def directives; end
-
-  # The encoding of the template.
-  #
-  # source://prism//lib/prism/pack.rb#203
-  def encoding; end
-end
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
-
-# source://prism//lib/prism/pack.rb#56
-Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
-
-# Flags for parameter nodes.
-#
-# source://prism//lib/prism/node.rb#19202
-module Prism::ParameterFlags; end
-
-# a parameter name that has been repeated in the method signature
-#
-# source://prism//lib/prism/node.rb#19204
-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//lib/prism/node.rb#14543
-class Prism::ParametersNode < ::Prism::Node
-  # def initialize: (Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
-  #
-  # @return [ParametersNode] a new instance of ParametersNode
-  #
-  # source://prism//lib/prism/node.rb#14545
-  sig do
-    params(
-      source: Prism::Source,
-      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
-      optionals: T::Array[Prism::OptionalParameterNode],
-      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
-      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
-      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
-      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
-      block: T.nilable(Prism::BlockParameterNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14654
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14558
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader block: BlockParameterNode?
-  #
-  # source://prism//lib/prism/node.rb#14617
-  sig { returns(T.nilable(Prism::BlockParameterNode)) }
-  def block; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14563
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14581
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14568
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
-  #
-  # source://prism//lib/prism/node.rb#14586
-  sig do
-    params(
-      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
-      optionals: T::Array[Prism::OptionalParameterNode],
-      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
-      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
-      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
-      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
-      block: T.nilable(Prism::BlockParameterNode),
-      location: Prism::Location
-    ).returns(Prism::ParametersNode)
-  end
-  def copy(requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14563
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14594
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14620
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
-  #
-  # source://prism//lib/prism/node.rb#14614
-  sig do
-    returns(T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)))
-  end
-  def keyword_rest; end
-
-  # attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
-  #
-  # source://prism//lib/prism/node.rb#14611
-  sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) }
-  def keywords; end
-
-  # attr_reader optionals: Array[OptionalParameterNode]
-  #
-  # source://prism//lib/prism/node.rb#14602
-  sig { returns(T::Array[Prism::OptionalParameterNode]) }
-  def optionals; end
-
-  # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
-  #
-  # source://prism//lib/prism/node.rb#14608
-  sig do
-    returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)])
-  end
-  def posts; end
-
-  # attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
-  #
-  # source://prism//lib/prism/node.rb#14599
-  sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)]) }
-  def requireds; end
-
-  # attr_reader rest: RestParameterNode | ImplicitRestNode | nil
-  #
-  # source://prism//lib/prism/node.rb#14605
-  sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) }
-  def rest; end
-
-  # Mirrors the Method#parameters method.
-  #
-  # source://prism//lib/prism/node_ext.rb#253
-  sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
-  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//lib/prism/node.rb#14638
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14648
-    def type; end
-  end
-end
-
-# Represents a parenthesized expression
-#
-#     (10 + 34)
-#     ^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#14674
-class Prism::ParenthesesNode < ::Prism::Node
-  # def initialize: (Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
-  #
-  # @return [ParenthesesNode] a new instance of ParenthesesNode
-  #
-  # source://prism//lib/prism/node.rb#14676
-  sig do
-    params(
-      source: Prism::Source,
-      body: T.nilable(Prism::Node),
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, body, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14781
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14685
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#14720
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14690
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14742
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14730
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14702
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14695
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> ParenthesesNode
-  #
-  # source://prism//lib/prism/node.rb#14707
-  sig do
-    params(
-      body: T.nilable(Prism::Node),
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::ParenthesesNode)
-  end
-  def copy(body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14690
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14715
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14747
-  sig { override.returns(String) }
-  def inspect; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#85
-  def newline!(lines); end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14737
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14723
-  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//lib/prism/node.rb#14765
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14775
-    def type; end
-  end
-end
-
-# This represents an error that was encountered during parsing.
-#
-# source://prism//lib/prism/parse_result.rb#451
-class Prism::ParseError
-  # Create a new error object with the given message and location.
-  #
-  # @return [ParseError] a new instance of ParseError
-  #
-  # source://prism//lib/prism/parse_result.rb#466
-  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
-  def initialize(type, message, location, level); end
-
-  # Implement the hash pattern matching interface for ParseError.
-  #
-  # source://prism//lib/prism/parse_result.rb#474
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Returns a string representation of this error.
-  #
-  # source://prism//lib/prism/parse_result.rb#479
-  sig { returns(String) }
-  def inspect; end
-
-  # The level of this error.
-  #
-  # source://prism//lib/prism/parse_result.rb#463
-  sig { returns(Symbol) }
-  def level; end
-
-  # A Location object representing the location of this error in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#460
-  sig { returns(Prism::Location) }
-  def location; end
-
-  # The message associated with this error.
-  #
-  # source://prism//lib/prism/parse_result.rb#457
-  sig { returns(String) }
-  def message; end
-
-  # The type of error. This is an _internal_ symbol that is used for
-  # communicating with translation layers. It is not meant to be public API.
-  #
-  # source://prism//lib/prism/parse_result.rb#454
-  sig { returns(Symbol) }
-  def type; end
-end
-
-# This is a result specific to the `parse_lex` and `parse_lex_file` methods.
-#
-# source://prism//lib/prism/parse_result.rb#627
-class Prism::ParseLexResult < ::Prism::Result
-  # Create a new parse lex result object with the given values.
-  #
-  # @return [ParseLexResult] a new instance of ParseLexResult
-  #
-  # source://prism//lib/prism/parse_result.rb#633
-  sig do
-    params(
-      value: [Prism::ProgramNode, T::Array[T.untyped]],
-      comments: T::Array[Prism::Comment],
-      magic_comments: T::Array[Prism::MagicComment],
-      data_loc: T.nilable(Prism::Location),
-      errors: T::Array[Prism::ParseError],
-      warnings: T::Array[Prism::ParseWarning],
-      source: Prism::Source
-    ).void
-  end
-  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
-
-  # Implement the hash pattern matching interface for ParseLexResult.
-  #
-  # source://prism//lib/prism/parse_result.rb#639
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # A tuple of the syntax tree and the list of tokens that were parsed from
-  # the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#630
-  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
-  def value; end
-end
-
-# This is a result specific to the `parse` and `parse_file` methods.
-#
-# source://prism//lib/prism/parse_result.rb#576
-class Prism::ParseResult < ::Prism::Result
-  # Create a new parse result object with the given values.
-  #
-  # @return [ParseResult] a new instance of ParseResult
-  #
-  # source://prism//lib/prism/parse_result.rb#587
-  sig do
-    params(
-      value: Prism::ProgramNode,
-      comments: T::Array[Prism::Comment],
-      magic_comments: T::Array[Prism::MagicComment],
-      data_loc: T.nilable(Prism::Location),
-      errors: T::Array[Prism::ParseError],
-      warnings: T::Array[Prism::ParseWarning],
-      source: Prism::Source
-    ).void
-  end
-  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//lib/prism/parse_result.rb#598
-  def attach_comments!; end
-
-  # Implement the hash pattern matching interface for ParseResult.
-  #
-  # source://prism//lib/prism/parse_result.rb#593
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Walk the tree and mark nodes that are on a new line, loosely emulating
-  # the behavior of CRuby's `:line` tracepoint event.
-  #
-  # source://prism//lib/prism/parse_result.rb#604
-  def mark_newlines!; end
-
-  # The syntax tree that was parsed from the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#584
-  sig { returns(Prism::ProgramNode) }
-  def value; 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//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//lib/prism/parse_result/comments.rb#86
-  def initialize(parse_result); end
-
-  # Attach the comments to their respective locations in the tree by
-  # mutating the parse result.
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#92
-  def attach!; end
-
-  # The parse result that we are attaching comments to.
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#82
-  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//lib/prism/parse_result/comments.rb#119
-  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//lib/prism/parse_result/comments.rb#53
-class Prism::ParseResult::Comments::LocationTarget
-  # @return [LocationTarget] a new instance of LocationTarget
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#56
-  def initialize(location); end
-
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#68
-  def encloses?(comment); end
-
-  # source://prism//lib/prism/parse_result/comments.rb#64
-  def end_offset; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#72
-  def leading_comment(comment); end
-
-  # source://prism//lib/prism/parse_result/comments.rb#54
-  def location; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#60
-  def start_offset; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#76
-  def trailing_comment(comment); end
-end
-
-# A target for attaching comments that is based on a specific node's
-# location.
-#
-# source://prism//lib/prism/parse_result/comments.rb#22
-class Prism::ParseResult::Comments::NodeTarget
-  # @return [NodeTarget] a new instance of NodeTarget
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#25
-  def initialize(node); end
-
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/parse_result/comments.rb#37
-  def encloses?(comment); end
-
-  # source://prism//lib/prism/parse_result/comments.rb#33
-  def end_offset; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#42
-  def leading_comment(comment); end
-
-  # source://prism//lib/prism/parse_result/comments.rb#23
-  def node; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#29
-  def start_offset; end
-
-  # source://prism//lib/prism/parse_result/comments.rb#46
-  def trailing_comment(comment); 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.
-#
-# This file is autoloaded only when `mark_newlines!` is called, so the
-# re-opening of the various nodes in this file will only be performed in
-# that case. We do that to avoid storing the extra `@newline` instance
-# variable on every node if we don't need it.
-#
-# source://prism//lib/prism/parse_result/newlines.rb#25
-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//lib/prism/parse_result/newlines.rb#27
-  def initialize(lines); end
-
-  # Permit block/lambda nodes to mark newlines within themselves.
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#33
-  def visit_block_node(node); end
-
-  # Mark if/unless nodes as newlines.
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#47
-  def visit_if_node(node); end
-
-  # Permit block/lambda nodes to mark newlines within themselves.
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#33
-  def visit_lambda_node(node); end
-
-  # Permit statements lists to mark newlines within themselves.
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#55
-  def visit_statements_node(node); end
-
-  # Mark if/unless nodes as newlines.
-  #
-  # source://prism//lib/prism/parse_result/newlines.rb#47
-  def visit_unless_node(node); end
-end
-
-# This represents a warning that was encountered during parsing.
-#
-# source://prism//lib/prism/parse_result.rb#485
-class Prism::ParseWarning
-  # Create a new warning object with the given message and location.
-  #
-  # @return [ParseWarning] a new instance of ParseWarning
-  #
-  # source://prism//lib/prism/parse_result.rb#500
-  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
-  def initialize(type, message, location, level); end
-
-  # Implement the hash pattern matching interface for ParseWarning.
-  #
-  # source://prism//lib/prism/parse_result.rb#508
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Returns a string representation of this warning.
-  #
-  # source://prism//lib/prism/parse_result.rb#513
-  sig { returns(String) }
-  def inspect; end
-
-  # The level of this warning.
-  #
-  # source://prism//lib/prism/parse_result.rb#497
-  sig { returns(Symbol) }
-  def level; end
-
-  # A Location object representing the location of this warning in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#494
-  sig { returns(Prism::Location) }
-  def location; end
-
-  # The message associated with this warning.
-  #
-  # source://prism//lib/prism/parse_result.rb#491
-  sig { returns(String) }
-  def message; end
-
-  # The type of warning. This is an _internal_ symbol that is used for
-  # communicating with translation layers. It is not meant to be public API.
-  #
-  # source://prism//lib/prism/parse_result.rb#488
-  sig { returns(Symbol) }
-  def type; 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//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//lib/prism/pattern.rb#63
-  def initialize(query); end
-
-  # Compile the query into a callable object that can be used to match against
-  # nodes.
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/pattern.rb#70
-  def compile; end
-
-  # The query that this pattern was initialized with.
-  #
-  # source://prism//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//lib/prism/pattern.rb#86
-  def scan(root); end
-
-  private
-
-  # Shortcut for combining two procs into one that returns true if both return
-  # true.
-  #
-  # source://prism//lib/prism/pattern.rb#102
-  def combine_and(left, right); end
-
-  # Shortcut for combining two procs into one that returns true if either
-  # returns true.
-  #
-  # source://prism//lib/prism/pattern.rb#108
-  def combine_or(left, right); end
-
-  # in foo | bar
-  #
-  # source://prism//lib/prism/pattern.rb#143
-  def compile_alternation_pattern_node(node); end
-
-  # in [foo, bar, baz]
-  #
-  # source://prism//lib/prism/pattern.rb#118
-  def compile_array_pattern_node(node); end
-
-  # Compile a name associated with a constant.
-  #
-  # source://prism//lib/prism/pattern.rb#168
-  def compile_constant_name(node, name); end
-
-  # in Prism::ConstantReadNode
-  #
-  # source://prism//lib/prism/pattern.rb#148
-  def compile_constant_path_node(node); end
-
-  # in ConstantReadNode
-  # in String
-  #
-  # source://prism//lib/prism/pattern.rb#163
-  def compile_constant_read_node(node); end
-
-  # Raise an error because the given node is not supported.
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/pattern.rb#113
-  def compile_error(node); end
-
-  # in InstanceVariableReadNode[name: Symbol]
-  # in { name: Symbol }
-  #
-  # source://prism//lib/prism/pattern.rb#184
-  def compile_hash_pattern_node(node); end
-
-  # in nil
-  #
-  # source://prism//lib/prism/pattern.rb#214
-  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//lib/prism/pattern.rb#243
-  def compile_node(node); end
-
-  # in /foo/
-  #
-  # source://prism//lib/prism/pattern.rb#219
-  def compile_regular_expression_node(node); end
-
-  # in ""
-  # in "foo"
-  #
-  # source://prism//lib/prism/pattern.rb#227
-  def compile_string_node(node); end
-
-  # in :+
-  # in :foo
-  #
-  # source://prism//lib/prism/pattern.rb#235
-  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//lib/prism/pattern.rb#40
-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//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//lib/prism/node.rb#14793
-class Prism::PinnedExpressionNode < ::Prism::Node
-  # def initialize: (Prism::node expression, Location operator_loc, Location lparen_loc, Location rparen_loc, Location location) -> void
-  #
-  # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
-  #
-  # source://prism//lib/prism/node.rb#14795
-  sig do
-    params(
-      source: Prism::Source,
-      expression: Prism::Node,
-      operator_loc: Prism::Location,
-      lparen_loc: Prism::Location,
-      rparen_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, expression, operator_loc, lparen_loc, rparen_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#14911
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14805
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14810
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14820
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14815
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location, ?location: Location) -> PinnedExpressionNode
-  #
-  # source://prism//lib/prism/node.rb#14825
-  sig do
-    params(
-      expression: Prism::Node,
-      operator_loc: Prism::Location,
-      lparen_loc: Prism::Location,
-      rparen_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::PinnedExpressionNode)
-  end
-  def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14810
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14833
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader expression: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#14838
-  sig { returns(Prism::Node) }
-  def expression; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14877
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def lparen: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14867
-  sig { returns(String) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14848
-  sig { returns(Prism::Location) }
-  def lparen_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14862
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14841
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # def rparen: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14872
-  sig { returns(String) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14855
-  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//lib/prism/node.rb#14895
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#14905
-    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//lib/prism/node.rb#14924
-class Prism::PinnedVariableNode < ::Prism::Node
-  # def initialize: (Prism::node variable, Location operator_loc, Location location) -> void
-  #
-  # @return [PinnedVariableNode] a new instance of PinnedVariableNode
-  #
-  # source://prism//lib/prism/node.rb#14926
-  sig do
-    params(
-      source: Prism::Source,
-      variable: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, variable, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15016
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#14934
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14939
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#14949
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#14944
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?variable: Prism::node, ?operator_loc: Location, ?location: Location) -> PinnedVariableNode
-  #
-  # source://prism//lib/prism/node.rb#14954
-  sig do
-    params(
-      variable: Prism::Node,
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::PinnedVariableNode)
-  end
-  def copy(variable: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#14939
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { variable: Prism::node, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#14962
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#14982
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#14977
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#14970
-  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//lib/prism/node.rb#15000
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader variable: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#14967
-  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//lib/prism/node.rb#15010
-    def type; end
-  end
-end
-
-# Represents the use of the `END` keyword.
-#
-#     END { foo }
-#     ^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#15027
-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//lib/prism/node.rb#15029
-  sig do
-    params(
-      source: Prism::Source,
-      statements: T.nilable(Prism::StatementsNode),
-      keyword_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15147
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15039
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15044
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15108
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15091
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15056
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15049
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PostExecutionNode
-  #
-  # source://prism//lib/prism/node.rb#15061
-  sig do
-    params(
-      statements: T.nilable(Prism::StatementsNode),
-      keyword_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::PostExecutionNode)
-  end
-  def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15044
-  sig { override.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//lib/prism/node.rb#15069
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15113
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15098
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15077
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15103
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15084
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#15074
-  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//lib/prism/node.rb#15131
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#15141
-    def type; end
-  end
-end
-
-# Represents the use of the `BEGIN` keyword.
-#
-#     BEGIN { foo }
-#     ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#15160
-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//lib/prism/node.rb#15162
-  sig do
-    params(
-      source: Prism::Source,
-      statements: T.nilable(Prism::StatementsNode),
-      keyword_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15280
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15172
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15177
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15241
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15224
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15189
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15182
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PreExecutionNode
-  #
-  # source://prism//lib/prism/node.rb#15194
-  sig do
-    params(
-      statements: T.nilable(Prism::StatementsNode),
-      keyword_loc: Prism::Location,
-      opening_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::PreExecutionNode)
-  end
-  def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15177
-  sig { override.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//lib/prism/node.rb#15202
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15246
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15231
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15210
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15236
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15217
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#15207
-  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//lib/prism/node.rb#15264
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#15274
-    def type; end
-  end
-end
-
-# The top level node of any parse tree.
-#
-# source://prism//lib/prism/node.rb#15290
-class Prism::ProgramNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, StatementsNode statements, Location location) -> void
-  #
-  # @return [ProgramNode] a new instance of ProgramNode
-  #
-  # source://prism//lib/prism/node.rb#15292
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      statements: Prism::StatementsNode,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, statements, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15373
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15300
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15305
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15315
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15310
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?locals: Array[Symbol], ?statements: StatementsNode, ?location: Location) -> ProgramNode
-  #
-  # source://prism//lib/prism/node.rb#15320
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      statements: Prism::StatementsNode,
-      location: Prism::Location
-    ).returns(Prism::ProgramNode)
-  end
-  def copy(locals: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15305
-  sig { override.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//lib/prism/node.rb#15328
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15339
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#15333
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # attr_reader statements: StatementsNode
-  #
-  # source://prism//lib/prism/node.rb#15336
-  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//lib/prism/node.rb#15357
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#15367
-    def type; end
-  end
-end
-
-# Flags for range and flip-flop nodes.
-#
-# source://prism//lib/prism/node.rb#19208
-module Prism::RangeFlags; end
-
-# ... operator
-#
-# source://prism//lib/prism/node.rb#19210
-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//lib/prism/node.rb#15388
-class Prism::RangeNode < ::Prism::Node
-  # def initialize: (Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
-  #
-  # @return [RangeNode] a new instance of RangeNode
-  #
-  # source://prism//lib/prism/node.rb#15390
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      left: T.nilable(Prism::Node),
-      right: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, left, right, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15510
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15400
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15405
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15418
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15410
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> RangeNode
-  #
-  # source://prism//lib/prism/node.rb#15423
-  sig do
-    params(
-      flags: Integer,
-      left: T.nilable(Prism::Node),
-      right: T.nilable(Prism::Node),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::RangeNode)
-  end
-  def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15405
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#15431
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def exclude_end?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15466
-  sig { returns(T::Boolean) }
-  def exclude_end?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15476
-  sig { override.returns(String) }
-  def inspect; 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//lib/prism/node.rb#15446
-  sig { returns(T.nilable(Prism::Node)) }
-  def left; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15471
-  sig { returns(String) }
-  def operator; end
-
-  # The location of the `..` or `...` operator.
-  #
-  # source://prism//lib/prism/node.rb#15459
-  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//lib/prism/node.rb#15456
-  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//lib/prism/node.rb#15494
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#15436
-  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//lib/prism/node.rb#15504
-    def type; end
-  end
-end
-
-# Represents a rational number literal.
-#
-#     1.0r
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#15523
-class Prism::RationalNode < ::Prism::Node
-  # def initialize: (Integer flags, Integer numerator, Integer denominator, Location location) -> void
-  #
-  # @return [RationalNode] a new instance of RationalNode
-  #
-  # source://prism//lib/prism/node.rb#15525
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      numerator: Integer,
-      denominator: Integer,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, numerator, denominator, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15635
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15534
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def binary?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15581
-  sig { returns(T::Boolean) }
-  def binary?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15539
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15549
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15544
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?numerator: Integer, ?denominator: Integer, ?location: Location) -> RationalNode
-  #
-  # source://prism//lib/prism/node.rb#15554
-  sig do
-    params(
-      flags: Integer,
-      numerator: Integer,
-      denominator: Integer,
-      location: Prism::Location
-    ).returns(Prism::RationalNode)
-  end
-  def copy(flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def decimal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15586
-  sig { returns(T::Boolean) }
-  def decimal?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15539
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, numerator: Integer, denominator: Integer, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#15562
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # The denominator of the rational number.
-  #
-  #     1.5r # denominator 2
-  #
-  # source://prism//lib/prism/node.rb#15578
-  sig { returns(Integer) }
-  def denominator; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def hexadecimal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15596
-  sig { returns(T::Boolean) }
-  def hexadecimal?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15601
-  sig { override.returns(String) }
-  def inspect; end
-
-  # The numerator of the rational number.
-  #
-  #     1.5r # numerator 3
-  #
-  # source://prism//lib/prism/node.rb#15573
-  sig { returns(Integer) }
-  def numerator; end
-
-  # Returns the value of the node as an IntegerNode or a FloatNode. This
-  # method is deprecated in favor of #value or #numerator/#denominator.
-  #
-  # source://prism//lib/prism/node_ext.rb#114
-  def numeric; end
-
-  # def octal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15591
-  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//lib/prism/node.rb#15619
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # Returns the value of the node as a Ruby Rational.
-  #
-  # source://prism//lib/prism/node_ext.rb#108
-  sig { returns(Rational) }
-  def value; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#15567
-  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//lib/prism/node.rb#15629
-    def type; end
-  end
-end
-
-# Represents the use of the `redo` keyword.
-#
-#     redo
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#15647
-class Prism::RedoNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [RedoNode] a new instance of RedoNode
-  #
-  # source://prism//lib/prism/node.rb#15649
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15722
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15655
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15660
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15670
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15665
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> RedoNode
-  #
-  # source://prism//lib/prism/node.rb#15675
-  sig { params(location: Prism::Location).returns(Prism::RedoNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15660
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#15683
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15688
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#15706
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#15716
-    def type; end
-  end
-end
-
-# The Reflection module provides the ability to reflect on the structure of
-# the syntax tree itself, as opposed to looking at a single syntax tree. This
-# is useful in metaprogramming contexts.
-#
-# source://prism//lib/prism/reflection.rb#13
-module Prism::Reflection
-  class << self
-    # Returns the fields for the given node.
-    #
-    # source://prism//lib/prism/reflection.rb#104
-    sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
-    def fields_for(node); end
-  end
-end
-
-# A constant field represents a constant value on a node. Effectively, it
-# represents an identifier found within the source. It resolves to a symbol
-# in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#45
-class Prism::Reflection::ConstantField < ::Prism::Reflection::Field; end
-
-# A constant list field represents a list of constant values on a node. It
-# resolves to an array of symbols in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#55
-class Prism::Reflection::ConstantListField < ::Prism::Reflection::Field; end
-
-# A field represents a single piece of data on a node. It is the base class
-# for all other field types.
-#
-# source://prism//lib/prism/reflection.rb#16
-class Prism::Reflection::Field
-  # Initializes the field with the given name.
-  #
-  # @return [Field] a new instance of Field
-  #
-  # source://prism//lib/prism/reflection.rb#21
-  sig { params(name: Symbol).void }
-  def initialize(name); end
-
-  # The name of the field.
-  #
-  # source://prism//lib/prism/reflection.rb#18
-  sig { returns(Symbol) }
-  def name; end
-end
-
-# A flags field represents a bitset of flags on a node. It resolves to an
-# integer in Ruby. Note that the flags cannot be accessed directly on the
-# node because the integer is kept private. Instead, the various flags in
-# the bitset should be accessed through their query methods.
-#
-# source://prism//lib/prism/reflection.rb#92
-class Prism::Reflection::FlagsField < ::Prism::Reflection::Field
-  # Initializes the flags field with the given name and flags.
-  #
-  # @return [FlagsField] a new instance of FlagsField
-  #
-  # source://prism//lib/prism/reflection.rb#97
-  sig { params(name: Symbol, flags: T::Array[Symbol]).void }
-  def initialize(name, flags); end
-
-  # The names of the flags in the bitset.
-  #
-  # source://prism//lib/prism/reflection.rb#94
-  sig { returns(T::Array[Symbol]) }
-  def flags; end
-end
-
-# A float field represents a double-precision floating point value. It is
-# used exclusively to represent the value of a floating point literal. It
-# resolves to a Float in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#85
-class Prism::Reflection::FloatField < ::Prism::Reflection::Field; end
-
-# An integer field represents an integer value. It is used to represent the
-# value of an integer literal, the depth of local variables, and the number
-# of a numbered reference. It resolves to an Integer in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#79
-class Prism::Reflection::IntegerField < ::Prism::Reflection::Field; end
-
-# A location field represents the location of some part of the node in the
-# source code. For example, the location of a keyword or an operator. It
-# resolves to a Prism::Location in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#67
-class Prism::Reflection::LocationField < ::Prism::Reflection::Field; end
-
-# A node field represents a single child node in the syntax tree. It
-# resolves to a Prism::Node in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#28
-class Prism::Reflection::NodeField < ::Prism::Reflection::Field; end
-
-# A node list field represents a list of child nodes in the syntax tree. It
-# resolves to an array of Prism::Node instances in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#39
-class Prism::Reflection::NodeListField < ::Prism::Reflection::Field; end
-
-# An optional constant field represents a constant value on a node that may
-# or may not be present. It resolves to either a symbol or nil in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#50
-class Prism::Reflection::OptionalConstantField < ::Prism::Reflection::Field; end
-
-# An optional location field represents the location of some part of the
-# node in the source code that may or may not be present. It resolves to
-# either a Prism::Location or nil in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#73
-class Prism::Reflection::OptionalLocationField < ::Prism::Reflection::Field; end
-
-# An optional node field represents a single child node in the syntax tree
-# that may or may not be present. It resolves to either a Prism::Node or nil
-# in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#34
-class Prism::Reflection::OptionalNodeField < ::Prism::Reflection::Field; end
-
-# A string field represents a string value on a node. It almost always
-# represents the unescaped value of a string-like literal. It resolves to a
-# string in Ruby.
-#
-# source://prism//lib/prism/reflection.rb#61
-class Prism::Reflection::StringField < ::Prism::Reflection::Field; end
-
-# Flags for regular expression and match last line nodes.
-#
-# source://prism//lib/prism/node.rb#19214
-module Prism::RegularExpressionFlags; end
-
-# n - forces the ASCII-8BIT encoding
-#
-# source://prism//lib/prism/node.rb#19231
-Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
-
-# e - forces the EUC-JP encoding
-#
-# source://prism//lib/prism/node.rb#19228
-Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer)
-
-# x - ignores whitespace and allows comments in regular expressions
-#
-# source://prism//lib/prism/node.rb#19219
-Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to binary
-#
-# source://prism//lib/prism/node.rb#19243
-Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to US-ASCII
-#
-# source://prism//lib/prism/node.rb#19246
-Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to UTF-8
-#
-# source://prism//lib/prism/node.rb#19240
-Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# i - ignores the case of characters when matching
-#
-# source://prism//lib/prism/node.rb#19216
-Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer)
-
-# m - allows $ to match the end of lines within strings
-#
-# source://prism//lib/prism/node.rb#19222
-Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer)
-
-# o - only interpolates values into the regular expression once
-#
-# source://prism//lib/prism/node.rb#19225
-Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
-
-# u - forces the UTF-8 encoding
-#
-# source://prism//lib/prism/node.rb#19237
-Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
-
-# s - forces the Windows-31J encoding
-#
-# source://prism//lib/prism/node.rb#19234
-Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer)
-
-# Represents a regular expression literal with no interpolation.
-#
-#     /foo/i
-#     ^^^^^^
-#
-# source://prism//lib/prism/node.rb#15731
-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//lib/prism/node.rb#15733
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#15909
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15744
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def ascii_8bit?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15830
-  sig { returns(T::Boolean) }
-  def ascii_8bit?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15749
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15870
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15795
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15759
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15754
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def content: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15865
-  sig { returns(String) }
-  def content; end
-
-  # attr_reader content_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15788
-  sig { returns(Prism::Location) }
-  def content_loc; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> RegularExpressionNode
-  #
-  # source://prism//lib/prism/node.rb#15764
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).returns(Prism::RegularExpressionNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15749
-  sig { override.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//lib/prism/node.rb#15772
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def euc_jp?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15825
-  sig { returns(T::Boolean) }
-  def euc_jp?; end
-
-  # def extended?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15810
-  sig { returns(T::Boolean) }
-  def extended?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15850
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_us_ascii_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15855
-  sig { returns(T::Boolean) }
-  def forced_us_ascii_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15845
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def ignore_case?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15805
-  sig { returns(T::Boolean) }
-  def ignore_case?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15875
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def multi_line?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15815
-  sig { returns(T::Boolean) }
-  def multi_line?; end
-
-  # def once?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15820
-  sig { returns(T::Boolean) }
-  def once?; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#15860
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15781
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  sig { returns(Integer) }
-  def options; 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//lib/prism/node.rb#15893
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader unescaped: String
-  #
-  # source://prism//lib/prism/node.rb#15802
-  sig { returns(String) }
-  def unescaped; end
-
-  # def utf_8?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15840
-  sig { returns(T::Boolean) }
-  def utf_8?; end
-
-  # def windows_31j?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15835
-  sig { returns(T::Boolean) }
-  def windows_31j?; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#15777
-  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//lib/prism/node.rb#15903
-    def type; end
-  end
-end
-
-# source://prism//lib/prism/node_ext.rb#20
-module Prism::RegularExpressionOptions
-  # Returns a numeric value that represents the flags that were used to create
-  # the regular expression.
-  #
-  # source://prism//lib/prism/node_ext.rb#23
-  def options; end
-end
-
-# Represents a required keyword parameter to a method, block, or lambda definition.
-#
-#     def a(b: )
-#           ^^
-#     end
-#
-# source://prism//lib/prism/node.rb#15924
-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//lib/prism/node.rb#15926
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16021
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#15935
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15940
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#15950
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#15945
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?location: Location) -> RequiredKeywordParameterNode
-  #
-  # source://prism//lib/prism/node.rb#15955
-  sig do
-    params(
-      flags: Integer,
-      name: Symbol,
-      name_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::RequiredKeywordParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#15940
-  sig { override.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//lib/prism/node.rb#15963
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#15987
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#15972
-  sig { returns(Symbol) }
-  def name; end
-
-  # attr_reader name_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#15975
-  sig { returns(Prism::Location) }
-  def name_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#15982
-  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//lib/prism/node.rb#16005
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#15968
-  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//lib/prism/node.rb#16015
-    def type; end
-  end
-end
-
-# Represents a required parameter to a method, block, or lambda definition.
-#
-#     def a(b)
-#           ^
-#     end
-#
-# source://prism//lib/prism/node.rb#16034
-class Prism::RequiredParameterNode < ::Prism::Node
-  # def initialize: (Integer flags, Symbol name, Location location) -> void
-  #
-  # @return [RequiredParameterNode] a new instance of RequiredParameterNode
-  #
-  # source://prism//lib/prism/node.rb#16036
-  sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void }
-  def initialize(source, flags, name, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16123
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16044
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16049
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16059
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16054
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> RequiredParameterNode
-  #
-  # source://prism//lib/prism/node.rb#16064
-  sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) }
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16049
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16072
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16089
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol
-  #
-  # source://prism//lib/prism/node.rb#16081
-  sig { returns(Symbol) }
-  def name; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16084
-  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//lib/prism/node.rb#16107
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#16077
-  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//lib/prism/node.rb#16117
-    def type; end
-  end
-end
-
-# Represents an expression modified with a rescue.
-#
-#     foo rescue nil
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#16134
-class Prism::RescueModifierNode < ::Prism::Node
-  # def initialize: (Prism::node expression, Location keyword_loc, Prism::node rescue_expression, Location location) -> void
-  #
-  # @return [RescueModifierNode] a new instance of RescueModifierNode
-  #
-  # source://prism//lib/prism/node.rb#16136
-  sig do
-    params(
-      source: Prism::Source,
-      expression: Prism::Node,
-      keyword_loc: Prism::Location,
-      rescue_expression: Prism::Node,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, expression, keyword_loc, rescue_expression, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16230
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16145
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16150
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16160
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16155
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node, ?location: Location) -> RescueModifierNode
-  #
-  # source://prism//lib/prism/node.rb#16165
-  sig do
-    params(
-      expression: Prism::Node,
-      keyword_loc: Prism::Location,
-      rescue_expression: Prism::Node,
-      location: Prism::Location
-    ).returns(Prism::RescueModifierNode)
-  end
-  def copy(expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16150
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16173
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader expression: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#16178
-  sig { returns(Prism::Node) }
-  def expression; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16196
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#16191
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16181
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#115
-  def newline!(lines); end
-
-  # attr_reader rescue_expression: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#16188
-  sig { returns(Prism::Node) }
-  def rescue_expression; 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//lib/prism/node.rb#16214
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#16224
-    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//lib/prism/node.rb#16247
-class Prism::RescueNode < ::Prism::Node
-  # def initialize: (Location keyword_loc, Array[Prism::node] exceptions, Location? operator_loc, Prism::node? reference, StatementsNode? statements, RescueNode? consequent, Location location) -> void
-  #
-  # @return [RescueNode] a new instance of RescueNode
-  #
-  # source://prism//lib/prism/node.rb#16249
-  sig do
-    params(
-      source: Prism::Source,
-      keyword_loc: Prism::Location,
-      exceptions: T::Array[Prism::Node],
-      operator_loc: T.nilable(Prism::Location),
-      reference: T.nilable(Prism::Node),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::RescueNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16375
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16261
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16266
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16281
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16271
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader consequent: RescueNode?
-  #
-  # source://prism//lib/prism/node.rb#16328
-  sig { returns(T.nilable(Prism::RescueNode)) }
-  def consequent; end
-
-  # def copy: (?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: Prism::node?, ?statements: StatementsNode?, ?consequent: RescueNode?, ?location: Location) -> RescueNode
-  #
-  # source://prism//lib/prism/node.rb#16286
-  sig do
-    params(
-      keyword_loc: Prism::Location,
-      exceptions: T::Array[Prism::Node],
-      operator_loc: T.nilable(Prism::Location),
-      reference: T.nilable(Prism::Node),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::RescueNode),
-      location: Prism::Location
-    ).returns(Prism::RescueNode)
-  end
-  def copy(keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16266
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: Prism::node?, statements: StatementsNode?, consequent: RescueNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16294
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader exceptions: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#16306
-  sig { returns(T::Array[Prism::Node]) }
-  def exceptions; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16341
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#16331
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16299
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def operator: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#16336
-  sig { returns(T.nilable(String)) }
-  def operator; end
-
-  # attr_reader operator_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#16309
-  sig { returns(T.nilable(Prism::Location)) }
-  def operator_loc; end
-
-  # attr_reader reference: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#16322
-  sig { returns(T.nilable(Prism::Node)) }
-  def reference; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#16325
-  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//lib/prism/node.rb#16359
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#16369
-    def type; end
-  end
-end
-
-# Represents a rest parameter to a method, block, or lambda definition.
-#
-#     def a(*b)
-#           ^^
-#     end
-#
-# source://prism//lib/prism/node.rb#16392
-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//lib/prism/node.rb#16394
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, name, name_loc, operator_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16508
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16404
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16409
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16419
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16414
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> RestParameterNode
-  #
-  # source://prism//lib/prism/node.rb#16424
-  sig do
-    params(
-      flags: Integer,
-      name: T.nilable(Symbol),
-      name_loc: T.nilable(Prism::Location),
-      operator_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::RestParameterNode)
-  end
-  def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16409
-  sig { override.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//lib/prism/node.rb#16432
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16474
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader name: Symbol?
-  #
-  # source://prism//lib/prism/node.rb#16441
-  sig { returns(T.nilable(Symbol)) }
-  def name; end
-
-  # attr_reader name_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#16444
-  sig { returns(T.nilable(Prism::Location)) }
-  def name_loc; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#16469
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16457
-  sig { returns(Prism::Location) }
-  def operator_loc; end
-
-  # def repeated_parameter?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16464
-  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//lib/prism/node.rb#16492
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#16437
-  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//lib/prism/node.rb#16502
-    def type; end
-  end
-end
-
-# This represents the result of a call to ::parse or ::parse_file. It contains
-# the requested structure, any comments that were encounters, and any errors
-# that were encountered.
-#
-# source://prism//lib/prism/parse_result.rb#521
-class Prism::Result
-  # Create a new result object with the given values.
-  #
-  # @return [Result] a new instance of Result
-  #
-  # source://prism//lib/prism/parse_result.rb#543
-  sig do
-    params(
-      comments: T::Array[Prism::Comment],
-      magic_comments: T::Array[Prism::MagicComment],
-      data_loc: T.nilable(Prism::Location),
-      errors: T::Array[Prism::ParseError],
-      warnings: T::Array[Prism::ParseWarning],
-      source: Prism::Source
-    ).void
-  end
-  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
-
-  # The list of comments that were encountered during parsing.
-  #
-  # source://prism//lib/prism/parse_result.rb#523
-  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//lib/prism/parse_result.rb#531
-  sig { returns(T.nilable(Prism::Location)) }
-  def data_loc; end
-
-  # Implement the hash pattern matching interface for Result.
-  #
-  # source://prism//lib/prism/parse_result.rb#553
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # Returns the encoding of the source code that was parsed.
-  #
-  # source://prism//lib/prism/parse_result.rb#558
-  sig { returns(Encoding) }
-  def encoding; end
-
-  # The list of errors that were generated during parsing.
-  #
-  # source://prism//lib/prism/parse_result.rb#534
-  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//lib/prism/parse_result.rb#570
-  sig { returns(T::Boolean) }
-  def failure?; end
-
-  # The list of magic comments that were encountered during parsing.
-  #
-  # source://prism//lib/prism/parse_result.rb#526
-  sig { returns(T::Array[Prism::MagicComment]) }
-  def magic_comments; end
-
-  # A Source instance that represents the source code that was parsed.
-  #
-  # source://prism//lib/prism/parse_result.rb#540
-  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//lib/prism/parse_result.rb#564
-  sig { returns(T::Boolean) }
-  def success?; end
-
-  # The list of warnings that were generated during parsing.
-  #
-  # source://prism//lib/prism/parse_result.rb#537
-  sig { returns(T::Array[Prism::ParseWarning]) }
-  def warnings; end
-end
-
-# Represents the use of the `retry` keyword.
-#
-#     retry
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#16521
-class Prism::RetryNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [RetryNode] a new instance of RetryNode
-  #
-  # source://prism//lib/prism/node.rb#16523
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16596
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16529
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16534
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16544
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16539
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> RetryNode
-  #
-  # source://prism//lib/prism/node.rb#16549
-  sig { params(location: Prism::Location).returns(Prism::RetryNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16534
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16557
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16562
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#16580
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#16590
-    def type; end
-  end
-end
-
-# Represents the use of the `return` keyword.
-#
-#     return 1
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#16605
-class Prism::ReturnNode < ::Prism::Node
-  # def initialize: (Integer flags, Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
-  #
-  # @return [ReturnNode] a new instance of ReturnNode
-  #
-  # source://prism//lib/prism/node.rb#16607
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, keyword_loc, arguments, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16709
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16616
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#16662
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16621
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16633
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16626
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?, ?location: Location) -> ReturnNode
-  #
-  # source://prism//lib/prism/node.rb#16638
-  sig do
-    params(
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      arguments: T.nilable(Prism::ArgumentsNode),
-      location: Prism::Location
-    ).returns(Prism::ReturnNode)
-  end
-  def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16621
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16646
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16675
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#16670
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16655
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def redundant?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16665
-  sig { returns(T::Boolean) }
-  def redundant?; 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//lib/prism/node.rb#16693
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#16651
-  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//lib/prism/node.rb#16703
-    def type; end
-  end
-end
-
-# Flags for return nodes.
-#
-# source://prism//lib/prism/node.rb#19250
-module Prism::ReturnNodeFlags; end
-
-# a return statement that is redundant because it is the last statement in a method
-#
-# source://prism//lib/prism/node.rb#19252
-Prism::ReturnNodeFlags::REDUNDANT = T.let(T.unsafe(nil), Integer)
-
-# Represents the `self` keyword.
-#
-#     self
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#16721
-class Prism::SelfNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [SelfNode] a new instance of SelfNode
-  #
-  # source://prism//lib/prism/node.rb#16723
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16796
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16729
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16734
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16744
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16739
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> SelfNode
-  #
-  # source://prism//lib/prism/node.rb#16749
-  sig { params(location: Prism::Location).returns(Prism::SelfNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16734
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16757
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16762
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#16780
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#16790
-    def type; end
-  end
-end
-
-# A module responsible for deserializing parse results.
-#
-# source://prism//lib/prism/serialize.rb#14
-module Prism::Serialize
-  class << self
-    # Deserialize the AST represented by the given string into a parse result.
-    #
-    # source://prism//lib/prism/serialize.rb#28
-    def load(input, serialized); end
-
-    # Deserialize the tokens represented by the given string into a parse
-    # result.
-    #
-    # source://prism//lib/prism/serialize.rb#40
-    def load_tokens(source, serialized); end
-  end
-end
-
-# source://prism//lib/prism/serialize.rb#44
-class Prism::Serialize::Loader
-  # @return [Loader] a new instance of Loader
-  #
-  # source://prism//lib/prism/serialize.rb#80
-  def initialize(source, serialized); end
-
-  # Returns the value of attribute constant_pool.
-  #
-  # source://prism//lib/prism/serialize.rb#77
-  def constant_pool; end
-
-  # Returns the value of attribute constant_pool_offset.
-  #
-  # source://prism//lib/prism/serialize.rb#77
-  def constant_pool_offset; end
-
-  # Returns the value of attribute encoding.
-  #
-  # source://prism//lib/prism/serialize.rb#76
-  def encoding; end
-
-  # Returns the value of attribute input.
-  #
-  # source://prism//lib/prism/serialize.rb#76
-  def input; end
-
-  # Returns the value of attribute io.
-  #
-  # source://prism//lib/prism/serialize.rb#76
-  def io; end
-
-  # source://prism//lib/prism/serialize.rb#118
-  def load_comments; end
-
-  # source://prism//lib/prism/serialize.rb#104
-  def load_encoding; end
-
-  # source://prism//lib/prism/serialize.rb#95
-  def load_header; end
-
-  # source://prism//lib/prism/serialize.rb#114
-  def load_line_offsets; end
-
-  # source://prism//lib/prism/serialize.rb#438
-  def load_metadata; end
-
-  # source://prism//lib/prism/serialize.rb#472
-  def load_nodes; end
-
-  # source://prism//lib/prism/serialize.rb#486
-  def load_result; end
-
-  # source://prism//lib/prism/serialize.rb#110
-  def load_start_line; end
-
-  # source://prism//lib/prism/serialize.rb#447
-  def load_tokens; end
-
-  # source://prism//lib/prism/serialize.rb#460
-  def load_tokens_result; end
-
-  # Returns the value of attribute serialized.
-  #
-  # source://prism//lib/prism/serialize.rb#76
-  def serialized; end
-
-  # Returns the value of attribute source.
-  #
-  # source://prism//lib/prism/serialize.rb#77
-  def source; end
-
-  # Returns the value of attribute start_line.
-  #
-  # source://prism//lib/prism/serialize.rb#78
-  def start_line; end
-
-  private
-
-  # source://prism//lib/prism/serialize.rb#572
-  def load_constant(index); end
-
-  # source://prism//lib/prism/serialize.rb#525
-  def load_double; end
-
-  # source://prism//lib/prism/serialize.rb#540
-  def load_embedded_string; end
-
-  # source://prism//lib/prism/serialize.rb#602
-  def load_error_level; end
-
-  # source://prism//lib/prism/serialize.rb#514
-  def load_integer; end
-
-  # source://prism//lib/prism/serialize.rb#556
-  def load_location; end
-
-  # source://prism//lib/prism/serialize.rb#560
-  def load_location_object; end
-
-  # source://prism//lib/prism/serialize.rb#631
-  def load_node; end
-
-  # source://prism//lib/prism/serialize.rb#597
-  def load_optional_constant; end
-
-  # source://prism//lib/prism/serialize.rb#564
-  def load_optional_location; end
-
-  # source://prism//lib/prism/serialize.rb#568
-  def load_optional_location_object; end
-
-  # source://prism//lib/prism/serialize.rb#533
-  def load_optional_node; end
-
-  # source://prism//lib/prism/serialize.rb#593
-  def load_required_constant; end
-
-  # source://prism//lib/prism/serialize.rb#544
-  def load_string; end
-
-  # source://prism//lib/prism/serialize.rb#529
-  def load_uint32; end
-
-  # source://prism//lib/prism/serialize.rb#509
-  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//lib/prism/serialize.rb#495
-  def load_varuint; end
-
-  # source://prism//lib/prism/serialize.rb#617
-  def load_warning_level; end
-end
-
-# source://prism//lib/prism/serialize.rb#127
-Prism::Serialize::Loader::DIAGNOSTIC_TYPES = T.let(T.unsafe(nil), Array)
-
-# StringIO is synchronized and that adds a high overhead on TruffleRuby.
-#
-# source://prism//lib/prism/serialize.rb#72
-Prism::Serialize::Loader::FastStringIO = StringIO
-
-# The major version of prism that we are expecting to find in the serialized
-# strings.
-#
-# source://prism//lib/prism/serialize.rb#17
-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//lib/prism/serialize.rb#21
-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//lib/prism/serialize.rb#25
-Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
-
-# The token types that can be indexed by their enum values.
-#
-# source://prism//lib/prism/serialize.rb#1863
-Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
-
-# This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
-#
-#     C = { a: 1 }
-#     ^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#16806
-class Prism::ShareableConstantNode < ::Prism::Node
-  # def initialize: (Integer flags, ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode write, Location location) -> void
-  #
-  # @return [ShareableConstantNode] a new instance of ShareableConstantNode
-  #
-  # source://prism//lib/prism/node.rb#16808
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, write, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#16905
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16816
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16821
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16831
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16826
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, ?location: Location) -> ShareableConstantNode
-  #
-  # source://prism//lib/prism/node.rb#16836
-  sig do
-    params(
-      flags: Integer,
-      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode),
-      location: Prism::Location
-    ).returns(Prism::ShareableConstantNode)
-  end
-  def copy(flags: T.unsafe(nil), write: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16821
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16844
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def experimental_copy?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16866
-  sig { returns(T::Boolean) }
-  def experimental_copy?; end
-
-  # def experimental_everything?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16861
-  sig { returns(T::Boolean) }
-  def experimental_everything?; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#16871
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def literal?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#16856
-  sig { returns(T::Boolean) }
-  def literal?; 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//lib/prism/node.rb#16889
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # The constant write that should be modified with the shareability state.
-  #
-  # source://prism//lib/prism/node.rb#16853
-  sig do
-    returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode))
-  end
-  def write; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#16849
-  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//lib/prism/node.rb#16899
-    def type; end
-  end
-end
-
-# Flags for shareable constant nodes.
-#
-# source://prism//lib/prism/node.rb#19256
-module Prism::ShareableConstantNodeFlags; end
-
-# constant writes that should be modified with shareable constant value experimental copy
-#
-# source://prism//lib/prism/node.rb#19264
-Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer)
-
-# constant writes that should be modified with shareable constant value experimental everything
-#
-# source://prism//lib/prism/node.rb#19261
-Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer)
-
-# constant writes that should be modified with shareable constant value literal
-#
-# source://prism//lib/prism/node.rb#19258
-Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer)
-
-# Represents a singleton class declaration involving the `class` keyword.
-#
-#     class << self end
-#     ^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#16916
-class Prism::SingletonClassNode < ::Prism::Node
-  # def initialize: (Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Prism::node expression, Prism::node? body, Location end_keyword_loc, Location location) -> void
-  #
-  # @return [SingletonClassNode] a new instance of SingletonClassNode
-  #
-  # source://prism//lib/prism/node.rb#16918
-  sig do
-    params(
-      source: Prism::Source,
-      locals: T::Array[Symbol],
-      class_keyword_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      expression: Prism::Node,
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17045
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#16930
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#16986
-  sig { returns(T.nilable(Prism::Node)) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16935
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def class_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#16996
-  sig { returns(String) }
-  def class_keyword; end
-
-  # attr_reader class_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16969
-  sig { returns(Prism::Location) }
-  def class_keyword_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#16948
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#16940
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?location: Location) -> SingletonClassNode
-  #
-  # source://prism//lib/prism/node.rb#16953
-  sig do
-    params(
-      locals: T::Array[Symbol],
-      class_keyword_loc: Prism::Location,
-      operator_loc: Prism::Location,
-      expression: Prism::Node,
-      body: T.nilable(Prism::Node),
-      end_keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::SingletonClassNode)
-  end
-  def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#16935
-  sig { override.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: Prism::node, body: Prism::node?, end_keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#16961
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#17006
-  sig { returns(String) }
-  def end_keyword; end
-
-  # attr_reader end_keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16989
-  sig { returns(Prism::Location) }
-  def end_keyword_loc; end
-
-  # attr_reader expression: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#16983
-  sig { returns(Prism::Node) }
-  def expression; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17011
-  sig { override.returns(String) }
-  def inspect; end
-
-  # attr_reader locals: Array[Symbol]
-  #
-  # source://prism//lib/prism/node.rb#16966
-  sig { returns(T::Array[Symbol]) }
-  def locals; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#17001
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#16976
-  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//lib/prism/node.rb#17029
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17039
-    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//lib/prism/parse_result.rb#7
-class Prism::Source
-  # Create a new source object with the given source code.
-  #
-  # @return [Source] a new instance of Source
-  #
-  # source://prism//lib/prism/parse_result.rb#26
-  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
-  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//lib/prism/parse_result.rb#78
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_column(byte_offset); end
-
-  # Return the character offset for the given byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#73
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def character_offset(byte_offset); end
-
-  # Returns the column number in code units for the given encoding for the
-  # given byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#95
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_column(byte_offset, encoding); end
-
-  # Returns the offset from the start of the file for the given byte offset
-  # counting in code units for the given encoding.
-  #
-  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
-  # concept of code units that differs from the number of characters in other
-  # encodings, it is not captured here.
-  #
-  # source://prism//lib/prism/parse_result.rb#88
-  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
-  def code_units_offset(byte_offset, encoding); end
-
-  # Return the column number for the given byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#68
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def column(byte_offset); end
-
-  # Returns the encoding of the source code, which is set by parameters to the
-  # parser or by the encoding magic comment.
-  #
-  # source://prism//lib/prism/parse_result.rb#34
-  sig { returns(Encoding) }
-  def encoding; end
-
-  # Binary search through the offsets to find the line number for the given
-  # byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#51
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def line(byte_offset); end
-
-  # Returns the byte offset of the end of the line corresponding to the given
-  # byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#63
-  def line_end(byte_offset); end
-
-  # Return the byte offset of the start of the line corresponding to the given
-  # byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#57
-  sig { params(byte_offset: Integer).returns(Integer) }
-  def line_start(byte_offset); end
-
-  # Returns the lines of the source code as an array of strings.
-  #
-  # source://prism//lib/prism/parse_result.rb#39
-  sig { returns(T::Array[String]) }
-  def lines; end
-
-  # The list of newline byte offsets in the source code.
-  #
-  # source://prism//lib/prism/parse_result.rb#23
-  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//lib/prism/parse_result.rb#45
-  sig { params(byte_offset: Integer, length: Integer).returns(String) }
-  def slice(byte_offset, length); end
-
-  # The source code that this source object represents.
-  #
-  # source://prism//lib/prism/parse_result.rb#17
-  sig { returns(String) }
-  def source; end
-
-  # The line number where this source starts.
-  #
-  # source://prism//lib/prism/parse_result.rb#20
-  sig { returns(Integer) }
-  def start_line; end
-
-  private
-
-  # Binary search through the offsets to find the line number for the given
-  # byte offset.
-  #
-  # source://prism//lib/prism/parse_result.rb#103
-  def find_line(byte_offset); end
-
-  class << self
-    # Create a new source object with the given source code. This method should
-    # be used instead of `new` and it will return either a `Source` or a
-    # specialized and more performant `ASCIISource` if no multibyte characters
-    # are present in the source code.
-    #
-    # source://prism//lib/prism/parse_result.rb#12
-    def for(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
-  end
-end
-
-# Represents the use of the `__ENCODING__` keyword.
-#
-#     __ENCODING__
-#     ^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#17061
-class Prism::SourceEncodingNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [SourceEncodingNode] a new instance of SourceEncodingNode
-  #
-  # source://prism//lib/prism/node.rb#17063
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17136
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17069
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17074
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17084
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17079
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> SourceEncodingNode
-  #
-  # source://prism//lib/prism/node.rb#17089
-  sig { params(location: Prism::Location).returns(Prism::SourceEncodingNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17074
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17097
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17102
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#17120
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17130
-    def type; end
-  end
-end
-
-# Represents the use of the `__FILE__` keyword.
-#
-#     __FILE__
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#17145
-class Prism::SourceFileNode < ::Prism::Node
-  # def initialize: (Integer flags, String filepath, Location location) -> void
-  #
-  # @return [SourceFileNode] a new instance of SourceFileNode
-  #
-  # source://prism//lib/prism/node.rb#17147
-  sig { params(source: Prism::Source, flags: Integer, filepath: String, location: Prism::Location).void }
-  def initialize(source, flags, filepath, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17249
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17155
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17160
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17170
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17165
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?filepath: String, ?location: Location) -> SourceFileNode
-  #
-  # source://prism//lib/prism/node.rb#17175
-  sig { params(flags: Integer, filepath: String, location: Prism::Location).returns(Prism::SourceFileNode) }
-  def copy(flags: T.unsafe(nil), filepath: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17160
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, filepath: String, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17183
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
-  #
-  # source://prism//lib/prism/node.rb#17192
-  sig { returns(String) }
-  def filepath; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17200
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17195
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def frozen?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17205
-  sig { returns(T::Boolean) }
-  def frozen?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17215
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def mutable?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17210
-  sig { returns(T::Boolean) }
-  def mutable?; 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//lib/prism/node.rb#17233
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#17188
-  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//lib/prism/node.rb#17243
-    def type; end
-  end
-end
-
-# Represents the use of the `__LINE__` keyword.
-#
-#     __LINE__
-#     ^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#17260
-class Prism::SourceLineNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [SourceLineNode] a new instance of SourceLineNode
-  #
-  # source://prism//lib/prism/node.rb#17262
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17335
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17268
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17273
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17283
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17278
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> SourceLineNode
-  #
-  # source://prism//lib/prism/node.rb#17288
-  sig { params(location: Prism::Location).returns(Prism::SourceLineNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17273
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17296
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17301
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#17319
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17329
-    def type; end
-  end
-end
-
-# Represents the use of the splat operator.
-#
-#     [*a]
-#      ^^
-#
-# source://prism//lib/prism/node.rb#17344
-class Prism::SplatNode < ::Prism::Node
-  # def initialize: (Location operator_loc, Prism::node? expression, Location location) -> void
-  #
-  # @return [SplatNode] a new instance of SplatNode
-  #
-  # source://prism//lib/prism/node.rb#17346
-  sig do
-    params(
-      source: Prism::Source,
-      operator_loc: Prism::Location,
-      expression: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, operator_loc, expression, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17438
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17354
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17359
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17371
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17364
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?operator_loc: Location, ?expression: Prism::node?, ?location: Location) -> SplatNode
-  #
-  # source://prism//lib/prism/node.rb#17376
-  sig do
-    params(
-      operator_loc: Prism::Location,
-      expression: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).returns(Prism::SplatNode)
-  end
-  def copy(operator_loc: T.unsafe(nil), expression: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17359
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, expression: Prism::node?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17384
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # attr_reader expression: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#17396
-  sig { returns(T.nilable(Prism::Node)) }
-  def expression; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17404
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def operator: () -> String
-  #
-  # source://prism//lib/prism/node.rb#17399
-  sig { returns(String) }
-  def operator; end
-
-  # attr_reader operator_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#17389
-  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//lib/prism/node.rb#17422
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17432
-    def type; end
-  end
-end
-
-# Represents a set of statements contained within some scope.
-#
-#     foo; bar; baz
-#     ^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#17449
-class Prism::StatementsNode < ::Prism::Node
-  # def initialize: (Array[Prism::node] body, Location location) -> void
-  #
-  # @return [StatementsNode] a new instance of StatementsNode
-  #
-  # source://prism//lib/prism/node.rb#17451
-  sig { params(source: Prism::Source, body: T::Array[Prism::Node], location: Prism::Location).void }
-  def initialize(source, body, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17528
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17458
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader body: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#17491
-  sig { returns(T::Array[Prism::Node]) }
-  def body; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17463
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17473
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17468
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?body: Array[Prism::node], ?location: Location) -> StatementsNode
-  #
-  # source://prism//lib/prism/node.rb#17478
-  sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) }
-  def copy(body: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17463
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { body: Array[Prism::node], location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17486
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17494
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#17512
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17522
-    def type; end
-  end
-end
-
-# Flags for string nodes.
-#
-# source://prism//lib/prism/node.rb#19268
-module Prism::StringFlags; end
-
-# internal bytes forced the encoding to binary
-#
-# source://prism//lib/prism/node.rb#19273
-Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to UTF-8
-#
-# source://prism//lib/prism/node.rb#19270
-Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# source://prism//lib/prism/node.rb#19276
-Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
-
-# source://prism//lib/prism/node.rb#19279
-Prism::StringFlags::MUTABLE = 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//lib/prism/node.rb#17545
-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//lib/prism/node.rb#17547
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      content_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      unescaped: String,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17700
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17558
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17563
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17661
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17615
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17573
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17568
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def content: () -> String
-  #
-  # source://prism//lib/prism/node.rb#17656
-  sig { returns(String) }
-  def content; end
-
-  # attr_reader content_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#17608
-  sig { returns(Prism::Location) }
-  def content_loc; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> StringNode
-  #
-  # source://prism//lib/prism/node.rb#17578
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      content_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      unescaped: String,
-      location: Prism::Location
-    ).returns(Prism::StringNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17563
-  sig { override.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//lib/prism/node.rb#17586
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17636
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17631
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def frozen?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17641
-  sig { returns(T::Boolean) }
-  def frozen?; end
-
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17666
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def mutable?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17646
-  sig { returns(T::Boolean) }
-  def mutable?; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17651
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17595
-  sig { returns(T.nilable(Prism::Location)) }
-  def opening_loc; end
-
-  # Occasionally it's helpful to treat a string as if it were interpolated so
-  # that there's a consistent interface for working with strings.
-  #
-  # source://prism//lib/prism/node_ext.rb#69
-  sig { returns(Prism::InterpolatedStringNode) }
-  def to_interpolated; 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//lib/prism/node.rb#17684
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader unescaped: String
-  #
-  # source://prism//lib/prism/node.rb#17628
-  sig { returns(String) }
-  def unescaped; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#17591
-  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//lib/prism/node.rb#17694
-    def type; end
-  end
-end
-
-# Represents the use of the `super` keyword with parentheses or arguments.
-#
-#     super()
-#     ^^^^^^^
-#
-#     super foo, bar
-#     ^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#17717
-class Prism::SuperNode < ::Prism::Node
-  # def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Prism::node? block, Location location) -> void
-  #
-  # @return [SuperNode] a new instance of SuperNode
-  #
-  # source://prism//lib/prism/node.rb#17719
-  sig do
-    params(
-      source: Prism::Source,
-      keyword_loc: Prism::Location,
-      lparen_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      rparen_loc: T.nilable(Prism::Location),
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#17854
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17730
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#17786
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # attr_reader block: Prism::node?
-  #
-  # source://prism//lib/prism/node.rb#17802
-  sig { returns(T.nilable(Prism::Node)) }
-  def block; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17735
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17748
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17740
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: Prism::node?, ?location: Location) -> SuperNode
-  #
-  # source://prism//lib/prism/node.rb#17753
-  sig do
-    params(
-      keyword_loc: Prism::Location,
-      lparen_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      rparen_loc: T.nilable(Prism::Location),
-      block: T.nilable(Prism::Node),
-      location: Prism::Location
-    ).returns(Prism::SuperNode)
-  end
-  def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17735
-  sig { override.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: Prism::node?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#17761
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17820
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#17805
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#17766
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17810
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17773
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17815
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17789
-  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//lib/prism/node.rb#17838
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#17848
-    def type; end
-  end
-end
-
-# Flags for symbol nodes.
-#
-# source://prism//lib/prism/node.rb#19283
-module Prism::SymbolFlags; end
-
-# internal bytes forced the encoding to binary
-#
-# source://prism//lib/prism/node.rb#19288
-Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to US-ASCII
-#
-# source://prism//lib/prism/node.rb#19291
-Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
-
-# internal bytes forced the encoding to UTF-8
-#
-# source://prism//lib/prism/node.rb#19285
-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//lib/prism/node.rb#17871
-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//lib/prism/node.rb#17873
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      value_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      unescaped: String,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, value_loc, closing_loc, unescaped, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18027
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#17884
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17889
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17988
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17947
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#17899
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#17894
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> SymbolNode
-  #
-  # source://prism//lib/prism/node.rb#17904
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: T.nilable(Prism::Location),
-      value_loc: T.nilable(Prism::Location),
-      closing_loc: T.nilable(Prism::Location),
-      unescaped: String,
-      location: Prism::Location
-    ).returns(Prism::SymbolNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#17889
-  sig { override.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//lib/prism/node.rb#17912
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17968
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_us_ascii_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17973
-  sig { returns(T::Boolean) }
-  def forced_us_ascii_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#17963
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#17993
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17978
-  sig { returns(T.nilable(String)) }
-  def opening; end
-
-  # attr_reader opening_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17921
-  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//lib/prism/node.rb#18011
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader unescaped: String
-  #
-  # source://prism//lib/prism/node.rb#17960
-  sig { returns(String) }
-  def unescaped; end
-
-  # def value: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#17983
-  sig { returns(T.nilable(String)) }
-  def value; end
-
-  # attr_reader value_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#17934
-  sig { returns(T.nilable(Prism::Location)) }
-  def value_loc; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#17917
-  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//lib/prism/node.rb#18021
-    def type; end
-  end
-end
-
-# This represents a token from the Ruby source.
-#
-# source://prism//lib/prism/parse_result.rb#645
-class Prism::Token
-  # Create a new token object with the given type, value, and location.
-  #
-  # @return [Token] a new instance of Token
-  #
-  # source://prism//lib/prism/parse_result.rb#657
-  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
-  def initialize(source, type, value, location); end
-
-  # Returns true if the given other token is equal to this token.
-  #
-  # source://prism//lib/prism/parse_result.rb#692
-  sig { params(other: T.untyped).returns(T::Boolean) }
-  def ==(other); end
-
-  # Implement the hash pattern matching interface for Token.
-  #
-  # source://prism//lib/prism/parse_result.rb#665
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # A Location object representing the location of this token in the source.
-  #
-  # source://prism//lib/prism/parse_result.rb#670
-  sig { returns(Prism::Location) }
-  def location; end
-
-  # Implement the pretty print interface for Token.
-  #
-  # source://prism//lib/prism/parse_result.rb#677
-  sig { params(q: T.untyped).void }
-  def pretty_print(q); end
-
-  # The type of token that this token is.
-  #
-  # source://prism//lib/prism/parse_result.rb#651
-  sig { returns(Symbol) }
-  def type; end
-
-  # A byteslice of the source that this token represents.
-  #
-  # source://prism//lib/prism/parse_result.rb#654
-  sig { returns(String) }
-  def value; end
-
-  private
-
-  # The Source object that represents the source this token came from.
-  #
-  # source://prism//lib/prism/parse_result.rb#647
-  sig { returns(Prism::Source) }
-  def source; end
-end
-
-# This module is responsible for converting the prism syntax tree into other
-# syntax trees.
-#
-# source://prism//lib/prism/translation.rb#6
-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//lib/prism/translation/parser.rb#16
-class Prism::Translation::Parser < ::Parser::Base
-  # The default encoding for Ruby files is UTF-8.
-  #
-  # source://prism//lib/prism/translation/parser.rb#41
-  def default_encoding; end
-
-  # Parses a source buffer and returns the AST.
-  #
-  # source://prism//lib/prism/translation/parser.rb#49
-  def parse(source_buffer); end
-
-  # Parses a source buffer and returns the AST and the source code comments.
-  #
-  # source://prism//lib/prism/translation/parser.rb#62
-  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//lib/prism/translation/parser.rb#79
-  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//lib/prism/translation/parser.rb#105
-  def try_declare_numparam(node); end
-
-  # source://prism//lib/prism/translation/parser.rb#36
-  sig { overridable.returns(Integer) }
-  def version; end
-
-  # source://prism//lib/prism/translation/parser.rb#45
-  def yyerror; end
-
-  private
-
-  # Build the parser gem AST from the prism AST.
-  #
-  # source://prism//lib/prism/translation/parser.rb#263
-  def build_ast(program, offset_cache); end
-
-  # Build the parser gem comments from the prism comments.
-  #
-  # source://prism//lib/prism/translation/parser.rb#268
-  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 an array where the
-  # index is the byte offset and the value is the character offset.
-  #
-  # source://prism//lib/prism/translation/parser.rb#246
-  def build_offset_cache(source); end
-
-  # Build a range from a prism location.
-  #
-  # source://prism//lib/prism/translation/parser.rb#280
-  def build_range(location, offset_cache); end
-
-  # Build the parser gem tokens from the prism tokens.
-  #
-  # source://prism//lib/prism/translation/parser.rb#275
-  def build_tokens(tokens, offset_cache); end
-
-  # Converts the version format handled by Parser to the format handled by Prism.
-  #
-  # source://prism//lib/prism/translation/parser.rb#289
-  def convert_for_prism(version); end
-
-  # Build a diagnostic from the given prism parse error.
-  #
-  # source://prism//lib/prism/translation/parser.rb#124
-  def error_diagnostic(error, offset_cache); end
-
-  # If there was a error generated during the parse, then raise an
-  # appropriate syntax error. Otherwise return the result.
-  #
-  # source://prism//lib/prism/translation/parser.rb#224
-  def unwrap(result, offset_cache); end
-
-  # This is a hook to allow consumers to disable some errors if they don't
-  # want them to block creating the syntax tree.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/parser.rb#113
-  def valid_error?(error); end
-
-  # This is a hook to allow consumers to disable some warnings if they don't
-  # want them to block creating the syntax tree.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/parser.rb#119
-  def valid_warning?(warning); end
-
-  # Build a diagnostic from the given prism parse warning.
-  #
-  # source://prism//lib/prism/translation/parser.rb#197
-  def warning_diagnostic(warning, offset_cache); end
-end
-
-# This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
-#
-# source://prism//lib/prism/translation/parser33.rb#6
-class Prism::Translation::Parser33 < ::Prism::Translation::Parser
-  # source://prism//lib/prism/translation/parser33.rb#7
-  sig { override.returns(Integer) }
-  def version; end
-end
-
-# This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
-#
-# source://prism//lib/prism/translation/parser34.rb#6
-class Prism::Translation::Parser34 < ::Prism::Translation::Parser
-  # source://prism//lib/prism/translation/parser34.rb#7
-  sig { override.returns(Integer) }
-  def version; end
-end
-
-# A visitor that knows how to convert a prism syntax tree into the
-# whitequark/parser gem's syntax tree.
-#
-# source://prism//lib/prism/translation/parser/compiler.rb#8
-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//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//lib/prism/translation/parser/compiler.rb#18
-  def builder; end
-
-  # The types of values that can be forwarded in the current scope.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#29
-  def forwarding; end
-
-  # Whether or not the current node is in a destructure.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#32
-  def in_destructure; end
-
-  # Whether or not the current node is in a pattern.
-  #
-  # source://prism//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//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//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//lib/prism/translation/parser/compiler.rb#22
-  def source_buffer; end
-
-  # alias $foo $bar
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#58
-  def visit_alias_global_variable_node(node); end
-
-  # alias foo bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#52
-  def visit_alias_method_node(node); end
-
-  # foo => bar | baz
-  #        ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#64
-  def visit_alternation_pattern_node(node); end
-
-  # a and b
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#70
-  def visit_and_node(node); end
-
-  # foo(bar)
-  #     ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#105
-  def visit_arguments_node(node); end
-
-  # []
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#76
-  def visit_array_node(node); end
-
-  # foo => [bar]
-  #        ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#82
-  def visit_array_pattern_node(node); end
-
-  # { a: 1 }
-  #   ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#111
-  def visit_assoc_node(node); end
-
-  # def foo(**); bar(**); end
-  #                  ^^
-  #
-  # { **foo }
-  #   ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#160
-  def visit_assoc_splat_node(node); end
-
-  # $+
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#172
-  def visit_back_reference_read_node(node); end
-
-  # begin end
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#178
-  def visit_begin_node(node); end
-
-  # foo(&bar)
-  #     ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#216
-  def visit_block_argument_node(node); end
-
-  # foo { |; bar| }
-  #          ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#222
-  def visit_block_local_variable_node(node); end
-
-  # A block on a keyword or method call.
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#227
-  def visit_block_node(node); end
-
-  # def foo(&bar); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#233
-  def visit_block_parameter_node(node); end
-
-  # A block's parameters.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#238
-  def visit_block_parameters_node(node); end
-
-  # break
-  # ^^^^^
-  #
-  # break foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#247
-  def visit_break_node(node); end
-
-  # foo.bar &&= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#352
-  def visit_call_and_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # foo.bar
-  # ^^^^^^^
-  #
-  # foo.bar() {}
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#259
-  def visit_call_node(node); end
-
-  # foo.bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#333
-  def visit_call_operator_write_node(node); end
-
-  # foo.bar ||= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#371
-  def visit_call_or_write_node(node); end
-
-  # foo.bar, = 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#390
-  def visit_call_target_node(node); end
-
-  # foo => bar => baz
-  #        ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#402
-  def visit_capture_pattern_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#421
-  def visit_case_match_node(node); end
-
-  # case foo; when bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#408
-  def visit_case_node(node); end
-
-  # class Foo; end
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#434
-  def visit_class_node(node); end
-
-  # @@foo &&= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#473
-  def visit_class_variable_and_write_node(node); end
-
-  # @@foo += bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#463
-  def visit_class_variable_operator_write_node(node); end
-
-  # @@foo ||= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#483
-  def visit_class_variable_or_write_node(node); end
-
-  # @@foo
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#447
-  def visit_class_variable_read_node(node); end
-
-  # @@foo, = bar
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#493
-  def visit_class_variable_target_node(node); end
-
-  # @@foo = 1
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#453
-  def visit_class_variable_write_node(node); end
-
-  # Foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#524
-  def visit_constant_and_write_node(node); end
-
-  # Foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#514
-  def visit_constant_operator_write_node(node); end
-
-  # Foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#534
-  def visit_constant_or_write_node(node); end
-
-  # Foo::Bar &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#590
-  def visit_constant_path_and_write_node(node); end
-
-  # Foo::Bar
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#550
-  def visit_constant_path_node(node); end
-
-  # Foo::Bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#580
-  def visit_constant_path_operator_write_node(node); end
-
-  # Foo::Bar ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#600
-  def visit_constant_path_or_write_node(node); end
-
-  # Foo::Bar, = baz
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#610
-  def visit_constant_path_target_node(node); end
-
-  # Foo::Bar = 1
-  # ^^^^^^^^^^^^
-  #
-  # Foo::Foo, Bar::Bar = 1
-  # ^^^^^^^^  ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#570
-  def visit_constant_path_write_node(node); end
-
-  # Foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#499
-  def visit_constant_read_node(node); end
-
-  # Foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#544
-  def visit_constant_target_node(node); end
-
-  # Foo = 1
-  # ^^^^^^^
-  #
-  # Foo, Bar = 1
-  # ^^^  ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#508
-  def visit_constant_write_node(node); end
-
-  # def foo; end
-  # ^^^^^^^^^^^^
-  #
-  # def self.foo; end
-  # ^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#619
-  def visit_def_node(node); end
-
-  # defined? a
-  # ^^^^^^^^^^
-  #
-  # defined?(a)
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#666
-  def visit_defined_node(node); end
-
-  # if foo then bar else baz end
-  #                 ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#678
-  def visit_else_node(node); end
-
-  # "foo #{bar}"
-  #      ^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#684
-  def visit_embedded_statements_node(node); end
-
-  # "foo #@bar"
-  #      ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#694
-  def visit_embedded_variable_node(node); end
-
-  # begin; foo; ensure; bar; end
-  #             ^^^^^^^^^^^^
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#700
-  def visit_ensure_node(node); end
-
-  # false
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#706
-  def visit_false_node(node); end
-
-  # foo => [*, bar, *]
-  #        ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#712
-  def visit_find_pattern_node(node); end
-
-  # 0..5
-  # ^^^^
-  # if foo .. bar; end
-  #    ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1475
-  def visit_flip_flop_node(node); end
-
-  # 1.0
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#724
-  def visit_float_node(node); end
-
-  # for foo in bar do end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#730
-  def visit_for_node(node); end
-
-  # def foo(...); bar(...); end
-  #                   ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#748
-  def visit_forwarding_arguments_node(node); end
-
-  # def foo(...); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#754
-  def visit_forwarding_parameter_node(node); end
-
-  # super
-  # ^^^^^
-  #
-  # super {}
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#763
-  def visit_forwarding_super_node(node); end
-
-  # $foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#801
-  def visit_global_variable_and_write_node(node); end
-
-  # $foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#791
-  def visit_global_variable_operator_write_node(node); end
-
-  # $foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#811
-  def visit_global_variable_or_write_node(node); end
-
-  # $foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#775
-  def visit_global_variable_read_node(node); end
-
-  # $foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#821
-  def visit_global_variable_target_node(node); end
-
-  # $foo = 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#781
-  def visit_global_variable_write_node(node); end
-
-  # {}
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#827
-  def visit_hash_node(node); end
-
-  # foo => {}
-  #        ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#837
-  def visit_hash_pattern_node(node); end
-
-  # if foo then bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar if foo
-  # ^^^^^^^^^^
-  #
-  # foo ? bar : baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#855
-  def visit_if_node(node); end
-
-  # 1i
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#897
-  def visit_imaginary_node(node); end
-
-  # { foo: }
-  #   ^^^^
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#903
-  def visit_implicit_node(node); end
-
-  # foo { |bar,| }
-  #           ^
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#909
-  def visit_implicit_rest_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#915
-  def visit_in_node(node); end
-
-  # foo[bar] &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#959
-  def visit_index_and_write_node(node); end
-
-  # foo[bar] += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#941
-  def visit_index_operator_write_node(node); end
-
-  # foo[bar] ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#977
-  def visit_index_or_write_node(node); end
-
-  # foo[bar], = 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#995
-  def visit_index_target_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1032
-  def visit_instance_variable_and_write_node(node); end
-
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1022
-  def visit_instance_variable_operator_write_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1042
-  def visit_instance_variable_or_write_node(node); end
-
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1006
-  def visit_instance_variable_read_node(node); end
-
-  # @foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1052
-  def visit_instance_variable_target_node(node); end
-
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1012
-  def visit_instance_variable_write_node(node); end
-
-  # 1
-  # ^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1058
-  def visit_integer_node(node); end
-
-  # /foo #{bar}/
-  # ^^^^^^^^^^^^
-  # if /foo #{bar}/ then end
-  #    ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1064
-  def visit_interpolated_match_last_line_node(node); end
-
-  # /foo #{bar}/
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1064
-  def visit_interpolated_regular_expression_node(node); end
-
-  # "foo #{bar}"
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1079
-  def visit_interpolated_string_node(node); end
-
-  # :"foo #{bar}"
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1113
-  def visit_interpolated_symbol_node(node); end
-
-  # `foo #{bar}`
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1123
-  def visit_interpolated_x_string_node(node); end
-
-  # -> { it }
-  #      ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1137
-  def visit_it_local_variable_read_node(node); end
-
-  # -> { it }
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1143
-  def visit_it_parameters_node(node); end
-
-  # foo(bar: baz)
-  #     ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1149
-  def visit_keyword_hash_node(node); end
-
-  # def foo(**bar); end
-  #         ^^^^^
-  #
-  # def foo(**); end
-  #         ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1158
-  def visit_keyword_rest_parameter_node(node); end
-
-  # -> {}
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1167
-  def visit_lambda_node(node); end
-
-  # foo &&= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1219
-  def visit_local_variable_and_write_node(node); end
-
-  # foo += bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1209
-  def visit_local_variable_operator_write_node(node); end
-
-  # foo ||= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1229
-  def visit_local_variable_or_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1193
-  def visit_local_variable_read_node(node); end
-
-  # foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1239
-  def visit_local_variable_target_node(node); end
-
-  # foo = 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1199
-  def visit_local_variable_write_node(node); end
-
-  # /foo/
-  # ^^^^^
-  # if /foo/ then end
-  #    ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1509
-  def visit_match_last_line_node(node); end
-
-  # foo in bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1249
-  def visit_match_predicate_node(node); end
-
-  # foo => bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1259
-  def visit_match_required_node(node); end
-
-  # /(?<foo>foo)/ =~ bar
-  # ^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1269
-  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.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1280
-  def visit_missing_node(node); end
-
-  # module Foo; end
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1286
-  def visit_module_node(node); end
-
-  # foo, bar = baz
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1297
-  def visit_multi_target_node(node); end
-
-  # foo, bar = baz
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1307
-  def visit_multi_write_node(node); end
-
-  # next
-  # ^^^^
-  #
-  # next foo
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1330
-  def visit_next_node(node); end
-
-  # nil
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1342
-  def visit_nil_node(node); end
-
-  # def foo(**nil); end
-  #         ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1348
-  def visit_no_keywords_parameter_node(node); end
-
-  # -> { _1 + _2 }
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1358
-  def visit_numbered_parameters_node(node); end
-
-  # $1
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1364
-  def visit_numbered_reference_read_node(node); end
-
-  # def foo(bar: baz); end
-  #         ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1370
-  def visit_optional_keyword_parameter_node(node); end
-
-  # def foo(bar = 1); end
-  #         ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1376
-  def visit_optional_parameter_node(node); end
-
-  # a or b
-  # ^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1382
-  def visit_or_node(node); end
-
-  # def foo(bar, *baz); end
-  #         ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1388
-  def visit_parameters_node(node); end
-
-  # ()
-  # ^^
-  #
-  # (1)
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1427
-  def visit_parentheses_node(node); end
-
-  # foo => ^(bar)
-  #        ^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1437
-  def visit_pinned_expression_node(node); end
-
-  # foo = 1 and bar => ^foo
-  #                    ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1444
-  def visit_pinned_variable_node(node); end
-
-  # END {}
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1449
-  def visit_post_execution_node(node); end
-
-  # BEGIN {}
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1459
-  def visit_pre_execution_node(node); end
-
-  # The top-level program node.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1469
-  def visit_program_node(node); end
-
-  # 0..5
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1475
-  def visit_range_node(node); end
-
-  # 1r
-  # ^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1497
-  def visit_rational_node(node); end
-
-  # redo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1503
-  def visit_redo_node(node); end
-
-  # /foo/
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1509
-  def visit_regular_expression_node(node); end
-
-  # def foo(bar:); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1535
-  def visit_required_keyword_parameter_node(node); end
-
-  # def foo(bar); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1541
-  def visit_required_parameter_node(node); end
-
-  # foo rescue bar
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1547
-  def visit_rescue_modifier_node(node); end
-
-  # begin; rescue; end
-  #        ^^^^^^^
-  #
-  # @raise [CompilationError]
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1565
-  def visit_rescue_node(node); end
-
-  # def foo(*bar); end
-  #         ^^^^
-  #
-  # def foo(*); end
-  #         ^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1574
-  def visit_rest_parameter_node(node); end
-
-  # retry
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1580
-  def visit_retry_node(node); end
-
-  # return
-  # ^^^^^^
-  #
-  # return 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1589
-  def visit_return_node(node); end
-
-  # self
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1601
-  def visit_self_node(node); end
-
-  # A shareable constant.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1606
-  def visit_shareable_constant_node(node); end
-
-  # class << self; end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1612
-  def visit_singleton_class_node(node); end
-
-  # __ENCODING__
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1624
-  def visit_source_encoding_node(node); end
-
-  # __FILE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1630
-  def visit_source_file_node(node); end
-
-  # __LINE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1636
-  def visit_source_line_node(node); end
-
-  # foo(*bar)
-  #     ^^^^
-  #
-  # def foo((bar, *baz)); end
-  #               ^^^^
-  #
-  # def foo(*); bar(*); end
-  #                 ^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1648
-  def visit_splat_node(node); end
-
-  # A list of statements.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1661
-  def visit_statements_node(node); end
-
-  # "foo"
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1667
-  def visit_string_node(node); end
-
-  # super(foo)
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1709
-  def visit_super_node(node); end
-
-  # :foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1732
-  def visit_symbol_node(node); end
-
-  # true
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1764
-  def visit_true_node(node); end
-
-  # undef foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1770
-  def visit_undef_node(node); end
-
-  # unless foo; bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar unless foo
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1779
-  def visit_unless_node(node); end
-
-  # until foo; bar end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # bar until foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1809
-  def visit_until_node(node); end
-
-  # case foo; when bar; end
-  #           ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1831
-  def visit_when_node(node); end
-
-  # while foo; bar end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # bar while foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1849
-  def visit_while_node(node); end
-
-  # `foo`
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1871
-  def visit_x_string_node(node); end
-
-  # yield
-  # ^^^^^
-  #
-  # yield 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1902
-  def visit_yield_node(node); end
-
-  private
-
-  # The parser gem automatically converts \r\n to \n, meaning our offsets
-  # need to be adjusted to always subtract 1 from the length.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2045
-  def chomped_bytesize(line); end
-
-  # Initialize a new compiler with the given option overrides, used to
-  # visit a subtree with the given options.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1916
-  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//lib/prism/translation/parser/compiler.rb#1923
-  def find_forwarding(node); end
-
-  # Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1936
-  def multi_target_elements(node); end
-
-  # Negate the value of a numeric node. This is a special case where you
-  # have a negative sign on one line and then a number on the next line.
-  # In normal Ruby, this will always be a method call. The parser gem,
-  # however, marks this as a numeric literal. We have to massage the tree
-  # here to get it into the correct form.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1948
-  def numeric_negate(message_loc, receiver); 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//lib/prism/translation/parser/compiler.rb#1962
-  def procarg0?(parameters); end
-
-  # Constructs a new source range from the given start and end offsets.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1979
-  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. Importantly it does not search past newlines or comments.
-  #
-  # Note that end_offset is allowed to be nil, in which case this will
-  # search until the end of the string.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1994
-  def srange_find(start_offset, end_offset, tokens); end
-
-  # Constructs a new source range from the given start and end offsets.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#1984
-  def srange_offsets(start_offset, end_offset); end
-
-  # Transform a location into a token that the parser gem expects.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2004
-  def token(location); end
-
-  # Visit a block node on a call.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2009
-  def visit_block(call, block); end
-
-  # Visit a heredoc that can be either a string or an xstring.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2051
-  def visit_heredoc(node); end
-
-  # Visit a numeric node and account for the optional sign.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2123
-  def visit_numeric(node, value); end
-
-  # Within the given block, track that we're within a pattern.
-  #
-  # source://prism//lib/prism/translation/parser/compiler.rb#2135
-  def within_pattern; end
-end
-
-# Raised when the tree is malformed or there is a bug in the compiler.
-#
-# source://prism//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//lib/prism/translation/parser/compiler.rb#1976
-Prism::Translation::Parser::Compiler::Range = Parser::Source::Range
-
-# source://prism//lib/prism/translation/parser.rb#17
-Prism::Translation::Parser::Diagnostic = Parser::Diagnostic
-
-# Accepts a list of prism tokens and converts them into the expected
-# format for the parser gem.
-#
-# source://prism//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//lib/prism/translation/parser/lexer.rb#204
-  def initialize(source_buffer, lexed, offset_cache); end
-
-  # An array of tuples that contain prism tokens and their associated lex
-  # state when they were lexed.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#197
-  def lexed; end
-
-  # A hash that maps offsets in bytes to offsets in characters.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#200
-  def offset_cache; end
-
-  # The Parser::Source::Buffer that the tokens were lexed from.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#193
-  def source_buffer; end
-
-  # Convert the prism tokens into the expected format for the parser gem.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#214
-  def to_a; end
-
-  private
-
-  # Parse a complex from the string representation.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#387
-  def parse_complex(value); end
-
-  # Parse a float from the string representation.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#380
-  def parse_float(value); end
-
-  # Parse an integer from the string representation.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#373
-  def parse_integer(value); end
-
-  # Parse a rational from the string representation.
-  #
-  # source://prism//lib/prism/translation/parser/lexer.rb#402
-  def parse_rational(value); end
-end
-
-# These constants represent flags in our lex state. We really, really
-# don't want to be using them and we really, really don't want to be
-# exposing them as part of our public API. Unfortunately, we don't have
-# another way of matching the exact tokens that the parser gem expects
-# without them. We should find another way to do this, but in the
-# meantime we'll hide them from the documentation and mark them as
-# private constants.
-#
-# source://prism//lib/prism/translation/parser/lexer.rb#187
-Prism::Translation::Parser::Lexer::EXPR_BEG = T.let(T.unsafe(nil), Integer)
-
-# source://prism//lib/prism/translation/parser/lexer.rb#188
-Prism::Translation::Parser::Lexer::EXPR_LABEL = T.let(T.unsafe(nil), Integer)
-
-# source://prism//lib/prism/translation/parser/lexer.rb#210
-Prism::Translation::Parser::Lexer::Range = Parser::Source::Range
-
-# The direct translating of types between the two lexers.
-#
-# source://prism//lib/prism/translation/parser/lexer.rb#10
-Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash)
-
-# 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//lib/prism/translation/parser.rb#23
-class Prism::Translation::Parser::PrismDiagnostic < ::Parser::Diagnostic
-  # Initialize a new diagnostic with the given message and location.
-  #
-  # @return [PrismDiagnostic] a new instance of PrismDiagnostic
-  #
-  # source://prism//lib/prism/translation/parser.rb#28
-  def initialize(message, level, reason, location); end
-
-  # This is the cached message coming from prism.
-  #
-  # source://prism//lib/prism/translation/parser.rb#25
-  def message; end
-end
-
-# source://prism//lib/prism/translation/parser.rb#34
-Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
-
-# This class provides 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. To use this class, you
-# treat `Prism::Translation::Ripper` effectively as you would treat the
-# `Ripper` class.
-#
-# Note that this class will serve the most common use cases, but Ripper's
-# API is extensive and undocumented. It relies on reporting the state of the
-# parser at any given time. We do our best to replicate that here, but
-# because it is a different architecture it is not possible to perfectly
-# replicate the behavior of Ripper.
-#
-# The main known difference is that we may omit dispatching some events in
-# some cases. This impacts the following events:
-#
-# - on_assign_error
-# - on_comma
-# - on_ignored_nl
-# - on_ignored_sp
-# - on_kw
-# - on_label_end
-# - on_lbrace
-# - on_lbracket
-# - on_lparen
-# - on_nl
-# - on_op
-# - on_operator_ambiguous
-# - on_rbrace
-# - on_rbracket
-# - on_rparen
-# - on_semicolon
-# - on_sp
-# - on_symbeg
-# - on_tstring_beg
-# - on_tstring_end
-#
-# source://prism//lib/prism/translation/ripper.rb#43
-class Prism::Translation::Ripper < ::Prism::Compiler
-  # Create a new Translation::Ripper object with the given source.
-  #
-  # @return [Ripper] a new instance of Ripper
-  #
-  # source://prism//lib/prism/translation/ripper.rb#444
-  def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
-
-  # The current column number of the parser.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#441
-  def column; end
-
-  # True if the parser encountered an error during parsing.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/ripper.rb#457
-  sig { returns(T::Boolean) }
-  def error?; end
-
-  # The filename of the source being parsed.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#435
-  def filename; end
-
-  # The current line number of the parser.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#438
-  def lineno; end
-
-  # Parse the source and return the result.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#462
-  sig { returns(T.untyped) }
-  def parse; end
-
-  # The source that is being parsed.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#432
-  def source; end
-
-  # alias $foo $bar
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#561
-  def visit_alias_global_variable_node(node); end
-
-  # alias foo bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#551
-  def visit_alias_method_node(node); end
-
-  # foo => bar | baz
-  #        ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#585
-  def visit_alternation_pattern_node(node); end
-
-  # a and b
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#605
-  def visit_and_node(node); end
-
-  # foo(bar)
-  #     ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#796
-  def visit_arguments_node(node); end
-
-  # []
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#615
-  def visit_array_node(node); end
-
-  # foo => [bar]
-  #        ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#775
-  def visit_array_pattern_node(node); end
-
-  # { a: 1 }
-  #   ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#803
-  def visit_assoc_node(node); end
-
-  # def foo(**); bar(**); end
-  #                  ^^
-  #
-  # { **foo }
-  #   ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#816
-  def visit_assoc_splat_node(node); end
-
-  # $+
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#825
-  def visit_back_reference_read_node(node); end
-
-  # begin end
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#832
-  def visit_begin_node(node); end
-
-  # foo(&bar)
-  #     ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#896
-  def visit_block_argument_node(node); end
-
-  # foo { |; bar| }
-  #          ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#902
-  def visit_block_local_variable_node(node); end
-
-  # Visit a BlockNode.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#908
-  def visit_block_node(node); end
-
-  # def foo(&bar); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#944
-  def visit_block_parameter_node(node); end
-
-  # A block's parameters.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#958
-  def visit_block_parameters_node(node); end
-
-  # break
-  # ^^^^^
-  #
-  # break foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#982
-  def visit_break_node(node); end
-
-  # foo.bar &&= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1194
-  def visit_call_and_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # foo.bar
-  # ^^^^^^^
-  #
-  # foo.bar() {}
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1002
-  def visit_call_node(node); end
-
-  # foo.bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1172
-  def visit_call_operator_write_node(node); end
-
-  # foo.bar ||= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1216
-  def visit_call_or_write_node(node); end
-
-  # foo.bar, = 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1238
-  def visit_call_target_node(node); end
-
-  # foo => bar => baz
-  #        ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1263
-  def visit_capture_pattern_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1286
-  def visit_case_match_node(node); end
-
-  # case foo; when bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1273
-  def visit_case_node(node); end
-
-  # class Foo; end
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1299
-  def visit_class_node(node); end
-
-  # @@foo &&= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1352
-  def visit_class_variable_and_write_node(node); end
-
-  # @@foo += bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1338
-  def visit_class_variable_operator_write_node(node); end
-
-  # @@foo ||= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1366
-  def visit_class_variable_or_write_node(node); end
-
-  # @@foo
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1317
-  def visit_class_variable_read_node(node); end
-
-  # @@foo, = bar
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1380
-  def visit_class_variable_target_node(node); end
-
-  # @@foo = 1
-  # ^^^^^^^^^
-  #
-  # @@foo, @@bar = 1
-  # ^^^^^  ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1327
-  def visit_class_variable_write_node(node); end
-
-  # Foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1422
-  def visit_constant_and_write_node(node); end
-
-  # Foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1408
-  def visit_constant_operator_write_node(node); end
-
-  # Foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1436
-  def visit_constant_or_write_node(node); end
-
-  # Foo::Bar &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1523
-  def visit_constant_path_and_write_node(node); end
-
-  # Foo::Bar
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1457
-  def visit_constant_path_node(node); end
-
-  # Foo::Bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1509
-  def visit_constant_path_operator_write_node(node); end
-
-  # Foo::Bar ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1537
-  def visit_constant_path_or_write_node(node); end
-
-  # Foo::Bar, = baz
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1551
-  def visit_constant_path_target_node(node); end
-
-  # Foo::Bar = 1
-  # ^^^^^^^^^^^^
-  #
-  # Foo::Foo, Bar::Bar = 1
-  # ^^^^^^^^  ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1480
-  def visit_constant_path_write_node(node); end
-
-  # Foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1387
-  def visit_constant_read_node(node); end
-
-  # Foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1450
-  def visit_constant_target_node(node); end
-
-  # Foo = 1
-  # ^^^^^^^
-  #
-  # Foo, Bar = 1
-  # ^^^  ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1397
-  def visit_constant_write_node(node); end
-
-  # def foo; end
-  # ^^^^^^^^^^^^
-  #
-  # def self.foo; end
-  # ^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1560
-  def visit_def_node(node); end
-
-  # defined? a
-  # ^^^^^^^^^^
-  #
-  # defined?(a)
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1607
-  def visit_defined_node(node); end
-
-  # if foo then bar else baz end
-  #                 ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1614
-  def visit_else_node(node); end
-
-  # "foo #{bar}"
-  #      ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1630
-  def visit_embedded_statements_node(node); end
-
-  # "foo #@bar"
-  #      ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1651
-  def visit_embedded_variable_node(node); end
-
-  # Visit an EnsureNode node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1662
-  def visit_ensure_node(node); end
-
-  # false
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1680
-  def visit_false_node(node); end
-
-  # foo => [*, bar, *]
-  #        ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1687
-  def visit_find_pattern_node(node); end
-
-  # if foo .. bar; end
-  #    ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1712
-  def visit_flip_flop_node(node); end
-
-  # 1.0
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1726
-  def visit_float_node(node); end
-
-  # for foo in bar do end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1732
-  def visit_for_node(node); end
-
-  # def foo(...); bar(...); end
-  #                   ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1749
-  def visit_forwarding_arguments_node(node); end
-
-  # def foo(...); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1756
-  def visit_forwarding_parameter_node(node); end
-
-  # super
-  # ^^^^^
-  #
-  # super {}
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1766
-  def visit_forwarding_super_node(node); end
-
-  # $foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1815
-  def visit_global_variable_and_write_node(node); end
-
-  # $foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1801
-  def visit_global_variable_operator_write_node(node); end
-
-  # $foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1829
-  def visit_global_variable_or_write_node(node); end
-
-  # $foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1780
-  def visit_global_variable_read_node(node); end
-
-  # $foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1843
-  def visit_global_variable_target_node(node); end
-
-  # $foo = 1
-  # ^^^^^^^^
-  #
-  # $foo, $bar = 1
-  # ^^^^  ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1790
-  def visit_global_variable_write_node(node); end
-
-  # {}
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1850
-  def visit_hash_node(node); end
-
-  # foo => {}
-  #        ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1865
-  def visit_hash_pattern_node(node); end
-
-  # if foo then bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar if foo
-  # ^^^^^^^^^^
-  #
-  # foo ? bar : baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1907
-  def visit_if_node(node); end
-
-  # 1i
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1943
-  def visit_imaginary_node(node); end
-
-  # { foo: }
-  #   ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1949
-  def visit_implicit_node(node); end
-
-  # foo { |bar,| }
-  #           ^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1954
-  def visit_implicit_rest_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1961
-  def visit_in_node(node); end
-
-  # foo[bar] &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1996
-  def visit_index_and_write_node(node); end
-
-  # foo[bar] += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1979
-  def visit_index_operator_write_node(node); end
-
-  # foo[bar] ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2013
-  def visit_index_or_write_node(node); end
-
-  # foo[bar], = 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2030
-  def visit_index_target_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2072
-  def visit_instance_variable_and_write_node(node); end
-
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2058
-  def visit_instance_variable_operator_write_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2086
-  def visit_instance_variable_or_write_node(node); end
-
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2040
-  def visit_instance_variable_read_node(node); end
-
-  # @foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2100
-  def visit_instance_variable_target_node(node); end
-
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2047
-  def visit_instance_variable_write_node(node); end
-
-  # 1
-  # ^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2107
-  def visit_integer_node(node); end
-
-  # if /foo #{bar}/ then end
-  #    ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2113
-  def visit_interpolated_match_last_line_node(node); end
-
-  # /foo #{bar}/
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2132
-  def visit_interpolated_regular_expression_node(node); end
-
-  # "foo #{bar}"
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2151
-  def visit_interpolated_string_node(node); end
-
-  # :"foo #{bar}"
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2179
-  def visit_interpolated_symbol_node(node); end
-
-  # `foo #{bar}`
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2192
-  def visit_interpolated_x_string_node(node); end
-
-  # -> { it }
-  #      ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2222
-  def visit_it_local_variable_read_node(node); end
-
-  # -> { it }
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2229
-  def visit_it_parameters_node(node); end
-
-  # foo(bar: baz)
-  #     ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2234
-  def visit_keyword_hash_node(node); end
-
-  # def foo(**bar); end
-  #         ^^^^^
-  #
-  # def foo(**); end
-  #         ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2246
-  def visit_keyword_rest_parameter_node(node); end
-
-  # -> {}
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2260
-  def visit_lambda_node(node); end
-
-  # foo &&= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2352
-  def visit_local_variable_and_write_node(node); end
-
-  # foo += bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2338
-  def visit_local_variable_operator_write_node(node); end
-
-  # foo ||= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2366
-  def visit_local_variable_or_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2320
-  def visit_local_variable_read_node(node); end
-
-  # foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2380
-  def visit_local_variable_target_node(node); end
-
-  # foo = 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2327
-  def visit_local_variable_write_node(node); end
-
-  # if /foo/ then end
-  #    ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2387
-  def visit_match_last_line_node(node); end
-
-  # foo in bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2402
-  def visit_match_predicate_node(node); end
-
-  # foo => bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2411
-  def visit_match_required_node(node); end
-
-  # /(?<foo>foo)/ =~ bar
-  # ^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2420
-  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.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2426
-  def visit_missing_node(node); end
-
-  # module Foo; end
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2432
-  def visit_module_node(node); end
-
-  # (foo, bar), bar = qux
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2449
-  def visit_multi_target_node(node); end
-
-  # foo, bar = baz
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2503
-  def visit_multi_write_node(node); end
-
-  # next
-  # ^^^^
-  #
-  # next foo
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2523
-  def visit_next_node(node); end
-
-  # nil
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2537
-  def visit_nil_node(node); end
-
-  # def foo(**nil); end
-  #         ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2544
-  def visit_no_keywords_parameter_node(node); end
-
-  # -> { _1 + _2 }
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2553
-  def visit_numbered_parameters_node(node); end
-
-  # $1
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2558
-  def visit_numbered_reference_read_node(node); end
-
-  # def foo(bar: baz); end
-  #         ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2565
-  def visit_optional_keyword_parameter_node(node); end
-
-  # def foo(bar = 1); end
-  #         ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2575
-  def visit_optional_parameter_node(node); end
-
-  # a or b
-  # ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2585
-  def visit_or_node(node); end
-
-  # def foo(bar, *baz); end
-  #         ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2595
-  def visit_parameters_node(node); end
-
-  # ()
-  # ^^
-  #
-  # (1)
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2622
-  def visit_parentheses_node(node); end
-
-  # foo => ^(bar)
-  #        ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2636
-  def visit_pinned_expression_node(node); end
-
-  # foo = 1 and bar => ^foo
-  #                    ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2645
-  def visit_pinned_variable_node(node); end
-
-  # END {}
-  # ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2651
-  def visit_post_execution_node(node); end
-
-  # BEGIN {}
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2666
-  def visit_pre_execution_node(node); end
-
-  # The top-level program node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2680
-  def visit_program_node(node); end
-
-  # 0..5
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2691
-  def visit_range_node(node); end
-
-  # 1r
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2705
-  def visit_rational_node(node); end
-
-  # redo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2711
-  def visit_redo_node(node); end
-
-  # /foo/
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2718
-  def visit_regular_expression_node(node); end
-
-  # def foo(bar:); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2740
-  def visit_required_keyword_parameter_node(node); end
-
-  # def foo(bar); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2747
-  def visit_required_parameter_node(node); end
-
-  # foo rescue bar
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2754
-  def visit_rescue_modifier_node(node); end
-
-  # begin; rescue; end
-  #        ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2764
-  def visit_rescue_node(node); end
-
-  # def foo(*bar); end
-  #         ^^^^
-  #
-  # def foo(*); end
-  #         ^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2822
-  def visit_rest_parameter_node(node); end
-
-  # retry
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2834
-  def visit_retry_node(node); end
-
-  # return
-  # ^^^^^^
-  #
-  # return 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2844
-  def visit_return_node(node); end
-
-  # self
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2858
-  def visit_self_node(node); end
-
-  # A shareable constant.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2864
-  def visit_shareable_constant_node(node); end
-
-  # class << self; end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2870
-  def visit_singleton_class_node(node); end
-
-  # __ENCODING__
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2880
-  def visit_source_encoding_node(node); end
-
-  # __FILE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2887
-  def visit_source_file_node(node); end
-
-  # __LINE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2894
-  def visit_source_line_node(node); end
-
-  # foo(*bar)
-  #     ^^^^
-  #
-  # def foo((bar, *baz)); end
-  #               ^^^^
-  #
-  # def foo(*); bar(*); end
-  #                 ^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2907
-  def visit_splat_node(node); end
-
-  # A list of statements.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2912
-  def visit_statements_node(node); end
-
-  # "foo"
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2929
-  def visit_string_node(node); end
-
-  # super(foo)
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3061
-  def visit_super_node(node); end
-
-  # :foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3082
-  def visit_symbol_node(node); end
-
-  # true
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3106
-  def visit_true_node(node); end
-
-  # undef foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3113
-  def visit_undef_node(node); end
-
-  # unless foo; bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar unless foo
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3125
-  def visit_unless_node(node); end
-
-  # until foo; bar end
-  # ^^^^^^^^^^^^^^^^^
-  #
-  # bar until foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3153
-  def visit_until_node(node); end
-
-  # case foo; when bar; end
-  #           ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3177
-  def visit_when_node(node); end
-
-  # while foo; bar end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # bar while foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3198
-  def visit_while_node(node); end
-
-  # `foo`
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3222
-  def visit_x_string_node(node); end
-
-  # yield
-  # ^^^^^
-  #
-  # yield 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3245
-  def visit_yield_node(node); end
-
-  private
-
-  # :stopdoc:
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def _dispatch_0; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def _dispatch_1(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def _dispatch_2(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def _dispatch_3(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def _dispatch_4(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3394
-  def _dispatch_5(_, _, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3395
-  def _dispatch_7(_, _, _, _, _, _, _); 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//lib/prism/translation/ripper.rb#3379
-  def bounds(location); end
-
-  # Returns true if the given node is a command node.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1163
-  def command?(node); end
-
-  # This method is called when the parser found syntax error.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3417
-  def compile_error(msg); end
-
-  # This method is provided by the Ripper C extension. It is called when a
-  # string needs to be dedented because of a tilde heredoc. It is expected
-  # that it will modify the string in place and return the number of bytes
-  # that were removed.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3432
-  def dedent_string(string, width); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_BEGIN(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_CHAR(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_END(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on___end__(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_alias(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_alias_error(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_aref(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_aref_field(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_arg_ambiguous(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_arg_paren(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_args_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_args_add_block(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_args_add_star(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_args_forward; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_args_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_array(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def on_aryptn(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_assign(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_assign_error(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_assoc_new(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_assoc_splat(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_assoclist_from_args(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_backref(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_backtick(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_bare_assoc_hash(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_begin(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_binary(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_block_var(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_blockarg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def on_bodystmt(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_brace_block(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_break(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_call(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_case(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_class(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_class_name_error(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_comma(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_command(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def on_command_call(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_comment(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_const(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_const_path_field(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_const_path_ref(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_const_ref(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_cvar(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_def(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_defined(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3394
-  def on_defs(_, _, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_do_block(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_dot2(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_dot3(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_dyna_symbol(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_else(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_elsif(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embdoc(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embdoc_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embdoc_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embexpr_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embexpr_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_embvar(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_ensure(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_excessed_comma; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_fcall(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_field(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_float(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def on_fndptn(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_for(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_gvar(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_hash(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_heredoc_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_heredoc_dedent(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_heredoc_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_hshptn(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_ident(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_if(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_if_mod(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_ifop(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_ignored_nl(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_ignored_sp(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_imaginary(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_in(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_int(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_ivar(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_kw(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_kwrest_param(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_label(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_label_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_lambda(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_lbrace(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_lbracket(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_lparen(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_magic_comment(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_massign(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_method_add_arg(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_method_add_block(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_mlhs_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_mlhs_add_post(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_mlhs_add_star(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_mlhs_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_mlhs_paren(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_module(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_mrhs_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_mrhs_add_star(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_mrhs_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_mrhs_new_from_args(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_next(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_nl(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_nokw_param(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_op(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_opassign(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_operator_ambiguous(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_param_error(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3395
-  def on_params(_, _, _, _, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_paren(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_parse_error(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_period(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_program(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_qsymbols_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_qsymbols_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_qsymbols_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_qwords_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_qwords_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_qwords_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_rational(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_rbrace(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_rbracket(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_redo; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_regexp_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_regexp_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_regexp_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_regexp_literal(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_regexp_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3393
-  def on_rescue(_, _, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_rescue_mod(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_rest_param(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_retry; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_return(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_return0; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_rparen(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_sclass(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_semicolon(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_sp(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_stmts_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_stmts_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_string_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_string_concat(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_string_content; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_string_dvar(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_string_embexpr(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_string_literal(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_super(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_symbeg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_symbol(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_symbol_literal(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_symbols_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_symbols_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_symbols_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_tlambda(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_tlambeg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_top_const_field(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_top_const_ref(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_tstring_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_tstring_content(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_tstring_end(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_unary(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_undef(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_unless(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_unless_mod(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_until(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_until_mod(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_var_alias(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_var_field(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_var_ref(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_vcall(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_void_stmt; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3392
-  def on_when(_, _, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_while(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_while_mod(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_word_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_word_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_words_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_words_beg(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_words_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_words_sep(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3391
-  def on_xstring_add(_, _); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_xstring_literal(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_xstring_new; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3390
-  def on_yield(_); end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_yield0; end
-
-  # source://prism//lib/prism/translation/ripper.rb#3389
-  def on_zsuper; end
-
-  # Lazily initialize the parse result.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3271
-  def result; end
-
-  # Returns true if there is a comma between the two locations.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3284
-  def trailing_comma?(left, right); end
-
-  # Visit one side of an alias global variable node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#570
-  def visit_alias_global_variable_node_value(node); end
-
-  # Visit a list of elements, like the elements of an array or arguments.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#756
-  def visit_arguments(elements); end
-
-  # Visit the clauses of a begin node to form an on_bodystmt call.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#840
-  def visit_begin_node_clauses(location, node, allow_newline); end
-
-  # Visit the body of a structure that can have either a set of statements
-  # or statements wrapped in rescue/else/ensure.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#875
-  def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end
-
-  # Visit the arguments and block of a call node and return the arguments
-  # and block as they should be used.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1136
-  def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end
-
-  # Visit a constant path that is part of a write node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#1489
-  def visit_constant_path_write_node_target(node); end
-
-  # Visit a destructured positional parameter node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2609
-  def visit_destructured_parameter_node(node); end
-
-  # Visit a string that is expressed using a <<~ heredoc.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2980
-  def visit_heredoc_node(parts, base); end
-
-  # Ripper gives back the escaped string content but strips out the common
-  # leading whitespace. Prism gives back the unescaped string content and
-  # a location for the escaped string content. Unfortunately these don't
-  # work well together, so here we need to re-derive the common leading
-  # whitespace.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2955
-  def visit_heredoc_node_whitespace(parts); end
-
-  # Visit a heredoc node that is representing a string.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3026
-  def visit_heredoc_string_node(node); end
-
-  # Visit a heredoc node that is representing an xstring.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3043
-  def visit_heredoc_x_string_node(node); end
-
-  # Visit the targets of a multi-target node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2462
-  def visit_multi_target_node_targets(lefts, rest, rights, skippable); end
-
-  # Visit a node that represents a number. We need to explicitly handle the
-  # unary - operator.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3323
-  def visit_number_node(node); end
-
-  # Visit a pattern within a pattern match. This is used to bypass the
-  # parenthesis node that can be used to wrap patterns.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#595
-  def visit_pattern_node(node); end
-
-  # Visit the list of statements of a statements node. We support nil
-  # statements in the list. This would normally not be allowed by the
-  # structure of the prism parse tree, but we manually add them here so that
-  # we can mirror Ripper's void stmt.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2921
-  def visit_statements_node_body(body); end
-
-  # Visit an individual part of a string-like node.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#2211
-  def visit_string_content(part); end
-
-  # Visit the string content of a particular node. This method is used to
-  # split into the various token types.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3296
-  def visit_token(token, allow_keywords = T.unsafe(nil)); end
-
-  # Dispatch a words_sep event that contains the space between the elements
-  # of list literals.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#745
-  def visit_words_sep(opening_loc, previous, current); end
-
-  # Visit a node that represents a write value. This is used to handle the
-  # special case of an implicit array that is generated without brackets.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3341
-  def visit_write_value(node); end
-
-  # Returns true if there is a semicolon between the two locations.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3289
-  def void_stmt?(left, right, allow_newline); end
-
-  # This method is called when weak warning is produced by the parser.
-  # +fmt+ and +args+ is printf style.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3408
-  def warn(fmt, *args); end
-
-  # This method is called when strong warning is produced by the parser.
-  # +fmt+ and +args+ is printf style.
-  #
-  # source://prism//lib/prism/translation/ripper.rb#3413
-  def warning(fmt, *args); end
-
-  class << self
-    # Tokenizes the Ruby program and returns an array of an array,
-    # which is formatted like
-    # <code>[[lineno, column], type, token, state]</code>.
-    # The +filename+ argument is mostly ignored.
-    # By default, this method does not handle syntax errors in +src+,
-    # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
-    #
-    #     require "ripper"
-    #     require "pp"
-    #
-    #     pp Ripper.lex("def m(a) nil end")
-    #     #=> [[[1,  0], :on_kw,     "def", FNAME    ],
-    #          [[1,  3], :on_sp,     " ",   FNAME    ],
-    #          [[1,  4], :on_ident,  "m",   ENDFN    ],
-    #          [[1,  5], :on_lparen, "(",   BEG|LABEL],
-    #          [[1,  6], :on_ident,  "a",   ARG      ],
-    #          [[1,  7], :on_rparen, ")",   ENDFN    ],
-    #          [[1,  8], :on_sp,     " ",   BEG      ],
-    #          [[1,  9], :on_kw,     "nil", END      ],
-    #          [[1, 12], :on_sp,     " ",   END      ],
-    #          [[1, 13], :on_kw,     "end", END      ]]
-    #
-    # source://prism//lib/prism/translation/ripper.rb#72
-    def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
-
-    # Parses the given Ruby program read from +src+.
-    # +src+ must be a String or an IO or a object with a #gets method.
-    #
-    # source://prism//lib/prism/translation/ripper.rb#46
-    def parse(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
-
-    # Parses +src+ and create S-exp tree.
-    # Returns more readable tree rather than Ripper.sexp_raw.
-    # This method is mainly for developer use.
-    # The +filename+ argument is mostly ignored.
-    # By default, this method does not handle syntax errors in +src+,
-    # returning +nil+ in such cases. Use the +raise_errors+ keyword
-    # to raise a SyntaxError for an error in +src+.
-    #
-    #     require "ripper"
-    #     require "pp"
-    #
-    #     pp Ripper.sexp("def m(a) nil end")
-    #       #=> [:program,
-    #            [[:def,
-    #             [:@ident, "m", [1, 4]],
-    #             [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
-    #             [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
-    #
-    # source://prism//lib/prism/translation/ripper.rb#381
-    def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
-
-    # Parses +src+ and create S-exp tree.
-    # This method is mainly for developer use.
-    # The +filename+ argument is mostly ignored.
-    # By default, this method does not handle syntax errors in +src+,
-    # returning +nil+ in such cases. Use the +raise_errors+ keyword
-    # to raise a SyntaxError for an error in +src+.
-    #
-    #     require "ripper"
-    #     require "pp"
-    #
-    #     pp Ripper.sexp_raw("def m(a) nil end")
-    #       #=> [:program,
-    #            [:stmts_add,
-    #             [:stmts_new],
-    #             [:def,
-    #              [:@ident, "m", [1, 4]],
-    #              [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
-    #              [:bodystmt,
-    #               [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
-    #               nil,
-    #               nil,
-    #               nil]]]]
-    #
-    # source://prism//lib/prism/translation/ripper.rb#416
-    def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
-  end
-end
-
-# A list of all of the Ruby binary operators.
-#
-# source://prism//lib/prism/translation/ripper.rb#337
-Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
-
-# This array contains name of all ripper events.
-#
-# source://prism//lib/prism/translation/ripper.rb#289
-Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array)
-
-# A list of all of the Ruby keywords.
-#
-# source://prism//lib/prism/translation/ripper.rb#292
-Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array)
-
-# This array contains name of parser events.
-#
-# source://prism//lib/prism/translation/ripper.rb#283
-Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array)
-
-# This contains a table of all of the parser events and their
-# corresponding arity.
-#
-# source://prism//lib/prism/translation/ripper.rb#84
-Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
-
-# This array contains name of scanner events.
-#
-# source://prism//lib/prism/translation/ripper.rb#286
-Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array)
-
-# This contains a table of all of the scanner events and their
-# corresponding arity.
-#
-# source://prism//lib/prism/translation/ripper.rb#227
-Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
-
-# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
-# returns the arrays of [type, *children].
-#
-# source://prism//lib/prism/translation/ripper/sexp.rb#10
-class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper
-  # :stopdoc:
-  #
-  # source://prism//lib/prism/translation/ripper/sexp.rb#13
-  def error; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_BEGIN(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_CHAR(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_END(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on___end__(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_alias(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_alias_error(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_aref(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_aref_field(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_arg_ambiguous(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_arg_paren(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_args_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_args_add_block(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_args_add_star(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_args_forward(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_args_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_array(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_aryptn(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_assign(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_assign_error(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_assoc_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_assoc_splat(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_assoclist_from_args(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_backref(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_backtick(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_bare_assoc_hash(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_begin(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_binary(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_block_var(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_blockarg(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_bodystmt(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_brace_block(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_break(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_call(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_case(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_class(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_class_name_error(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_comma(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_command(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_command_call(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_comment(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_const(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_const_path_field(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_const_path_ref(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_const_ref(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_cvar(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_def(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_defined(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_defs(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_do_block(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_dot2(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_dot3(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_dyna_symbol(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_else(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_elsif(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embdoc(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embdoc_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embdoc_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embexpr_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embexpr_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_embvar(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_ensure(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_excessed_comma(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_fcall(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_field(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_float(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_fndptn(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_for(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_gvar(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_hash(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_heredoc_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_heredoc_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_hshptn(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_ident(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_if(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_if_mod(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_ifop(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_ignored_nl(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_ignored_sp(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_imaginary(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_in(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_int(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_ivar(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_kw(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_kwrest_param(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_label(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_label_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_lambda(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_lbrace(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_lbracket(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_lparen(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_magic_comment(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_massign(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_method_add_arg(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_method_add_block(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mlhs_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mlhs_add_post(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mlhs_add_star(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mlhs_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mlhs_paren(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_module(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mrhs_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mrhs_add_star(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mrhs_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_mrhs_new_from_args(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_next(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_nl(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_nokw_param(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_op(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_opassign(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_operator_ambiguous(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_param_error(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_params(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_paren(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_period(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_program(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_qsymbols_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_qsymbols_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_qsymbols_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_qwords_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_qwords_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_qwords_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_rational(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_rbrace(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_rbracket(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_redo(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_regexp_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_regexp_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_regexp_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_regexp_literal(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_regexp_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_rescue(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_rescue_mod(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_rest_param(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_retry(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_return(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_return0(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_rparen(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_sclass(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_semicolon(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_sp(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_stmts_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_stmts_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_concat(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_content(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_dvar(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_embexpr(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_string_literal(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_super(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_symbeg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_symbol(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_symbol_literal(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_symbols_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_symbols_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_symbols_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_tlambda(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_tlambeg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_top_const_field(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_top_const_ref(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_tstring_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_tstring_content(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_tstring_end(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_unary(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_undef(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_unless(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_unless_mod(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_until(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_until_mod(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_var_alias(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_var_field(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_var_ref(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_vcall(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_void_stmt(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_when(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_while(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_while_mod(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_word_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_word_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_words_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_words_beg(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_words_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#55
-  def on_words_sep(tok); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_xstring_add(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_xstring_literal(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_xstring_new(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_yield(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_yield0(*args); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#47
-  def on_zsuper(*args); end
-
-  private
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#61
-  def compile_error(mesg); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#17
-  def dedent_element(e, width); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#61
-  def on_error(mesg); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#24
-  def on_heredoc_dedent(val, width); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#61
-  def on_parse_error(mesg); 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//lib/prism/translation/ripper/sexp.rb#74
-class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder
-  private
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def _dispatch_event_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def _dispatch_event_push(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_args_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_args_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#79
-  def on_heredoc_dedent(val, width); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_mlhs_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#109
-  def on_mlhs_add_post(list, post); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#105
-  def on_mlhs_add_star(list, star); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_mlhs_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#101
-  def on_mlhs_paren(list); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_mrhs_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_mrhs_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_qsymbols_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_qsymbols_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_qwords_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_qwords_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_regexp_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_regexp_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_stmts_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_stmts_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_string_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_symbols_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_symbols_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_word_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_word_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_words_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_words_new; end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#96
-  def on_xstring_add(list, item); end
-
-  # source://prism//lib/prism/translation/ripper/sexp.rb#92
-  def on_xstring_new; end
-end
-
-# This module is the entry-point for converting a prism syntax tree into the
-# seattlerb/ruby_parser gem's syntax tree.
-#
-# source://prism//lib/prism/translation/ruby_parser.rb#14
-class Prism::Translation::RubyParser
-  # Parse the given source and translate it into the seattlerb/ruby_parser
-  # gem's Sexp format.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1556
-  def parse(source, filepath = T.unsafe(nil)); end
-
-  # Parse the given file and translate it into the seattlerb/ruby_parser
-  # gem's Sexp format.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1562
-  def parse_file(filepath); end
-
-  private
-
-  # Translate the given parse result and filepath into the
-  # seattlerb/ruby_parser gem's Sexp format.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1584
-  def translate(result, filepath); end
-
-  class << self
-    # Parse the given source and translate it into the seattlerb/ruby_parser
-    # gem's Sexp format.
-    #
-    # source://prism//lib/prism/translation/ruby_parser.rb#1569
-    def parse(source, filepath = T.unsafe(nil)); end
-
-    # Parse the given file and translate it into the seattlerb/ruby_parser
-    # gem's Sexp format.
-    #
-    # source://prism//lib/prism/translation/ruby_parser.rb#1575
-    def parse_file(filepath); end
-  end
-end
-
-# A prism visitor that builds Sexp objects.
-#
-# source://prism//lib/prism/translation/ruby_parser.rb#16
-class Prism::Translation::RubyParser::Compiler < ::Prism::Compiler
-  # Initialize a new compiler with the given file name.
-  #
-  # @return [Compiler] a new instance of Compiler
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#31
-  def initialize(file, in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
-
-  # This is the name of the file that we are compiling. We set it on every
-  # Sexp object that is generated, and also use it to compile __FILE__
-  # nodes.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#20
-  def file; end
-
-  # Class variables will change their type based on if they are inside of
-  # a method definition or not, so we need to track that state.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#24
-  def in_def; end
-
-  # Some nodes will change their representation if they are inside of a
-  # pattern, so we need to track that state.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#28
-  def in_pattern; end
-
-  # alias $foo $bar
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#45
-  def visit_alias_global_variable_node(node); end
-
-  # alias foo bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#39
-  def visit_alias_method_node(node); end
-
-  # foo => bar | baz
-  #        ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#51
-  def visit_alternation_pattern_node(node); end
-
-  # a and b
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#57
-  def visit_and_node(node); end
-
-  # foo(bar)
-  #     ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#96
-  def visit_arguments_node(node); end
-
-  # []
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#63
-  def visit_array_node(node); end
-
-  # foo => [bar]
-  #        ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#73
-  def visit_array_pattern_node(node); end
-
-  # { a: 1 }
-  #   ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#102
-  def visit_assoc_node(node); end
-
-  # def foo(**); bar(**); end
-  #                  ^^
-  #
-  # { **foo }
-  #   ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#111
-  def visit_assoc_splat_node(node); end
-
-  # $+
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#121
-  def visit_back_reference_read_node(node); end
-
-  # begin end
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#127
-  def visit_begin_node(node); end
-
-  # foo(&bar)
-  #     ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#160
-  def visit_block_argument_node(node); end
-
-  # foo { |; bar| }
-  #          ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#168
-  def visit_block_local_variable_node(node); end
-
-  # A block on a keyword or method call.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#173
-  def visit_block_node(node); end
-
-  # def foo(&bar); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#179
-  def visit_block_parameter_node(node); end
-
-  # A block's parameters.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#184
-  def visit_block_parameters_node(node); end
-
-  # break
-  # ^^^^^
-  #
-  # break foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#224
-  def visit_break_node(node); end
-
-  # foo.bar &&= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#287
-  def visit_call_and_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # foo.bar
-  # ^^^^^^^
-  #
-  # foo.bar() {}
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#242
-  def visit_call_node(node); end
-
-  # foo.bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#277
-  def visit_call_operator_write_node(node); end
-
-  # foo.bar ||= baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#297
-  def visit_call_or_write_node(node); end
-
-  # foo.bar, = 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#320
-  def visit_call_target_node(node); end
-
-  # foo => bar => baz
-  #        ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#326
-  def visit_capture_pattern_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#338
-  def visit_case_match_node(node); end
-
-  # case foo; when bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#332
-  def visit_case_node(node); end
-
-  # class Foo; end
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#344
-  def visit_class_node(node); end
-
-  # @@foo &&= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#385
-  def visit_class_variable_and_write_node(node); end
-
-  # @@foo += bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#379
-  def visit_class_variable_operator_write_node(node); end
-
-  # @@foo ||= bar
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#391
-  def visit_class_variable_or_write_node(node); end
-
-  # @@foo
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#364
-  def visit_class_variable_read_node(node); end
-
-  # @@foo, = bar
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#397
-  def visit_class_variable_target_node(node); end
-
-  # @@foo = 1
-  # ^^^^^^^^^
-  #
-  # @@foo, @@bar = 1
-  # ^^^^^  ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#373
-  def visit_class_variable_write_node(node); end
-
-  # Foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#430
-  def visit_constant_and_write_node(node); end
-
-  # Foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#424
-  def visit_constant_operator_write_node(node); end
-
-  # Foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#436
-  def visit_constant_or_write_node(node); end
-
-  # Foo::Bar &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#473
-  def visit_constant_path_and_write_node(node); end
-
-  # Foo::Bar
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#448
-  def visit_constant_path_node(node); end
-
-  # Foo::Bar += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#467
-  def visit_constant_path_operator_write_node(node); end
-
-  # Foo::Bar ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#479
-  def visit_constant_path_or_write_node(node); end
-
-  # Foo::Bar, = baz
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#485
-  def visit_constant_path_target_node(node); end
-
-  # Foo::Bar = 1
-  # ^^^^^^^^^^^^
-  #
-  # Foo::Foo, Bar::Bar = 1
-  # ^^^^^^^^  ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#461
-  def visit_constant_path_write_node(node); end
-
-  # Foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#409
-  def visit_constant_read_node(node); end
-
-  # Foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#442
-  def visit_constant_target_node(node); end
-
-  # Foo = 1
-  # ^^^^^^^
-  #
-  # Foo, Bar = 1
-  # ^^^  ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#418
-  def visit_constant_write_node(node); end
-
-  # def foo; end
-  # ^^^^^^^^^^^^
-  #
-  # def self.foo; end
-  # ^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#501
-  def visit_def_node(node); end
-
-  # defined? a
-  # ^^^^^^^^^^
-  #
-  # defined?(a)
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#532
-  def visit_defined_node(node); end
-
-  # if foo then bar else baz end
-  #                 ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#538
-  def visit_else_node(node); end
-
-  # "foo #{bar}"
-  #      ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#544
-  def visit_embedded_statements_node(node); end
-
-  # "foo #@bar"
-  #      ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#552
-  def visit_embedded_variable_node(node); end
-
-  # begin; foo; ensure; bar; end
-  #             ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#558
-  def visit_ensure_node(node); end
-
-  # false
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#564
-  def visit_false_node(node); end
-
-  # foo => [*, bar, *]
-  #        ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#570
-  def visit_find_pattern_node(node); end
-
-  # if foo .. bar; end
-  #    ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#576
-  def visit_flip_flop_node(node); end
-
-  # 1.0
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#586
-  def visit_float_node(node); end
-
-  # for foo in bar do end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#592
-  def visit_for_node(node); end
-
-  # def foo(...); bar(...); end
-  #                   ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#598
-  def visit_forwarding_arguments_node(node); end
-
-  # def foo(...); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#604
-  def visit_forwarding_parameter_node(node); end
-
-  # super
-  # ^^^^^
-  #
-  # super {}
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#613
-  def visit_forwarding_super_node(node); end
-
-  # $foo &&= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#640
-  def visit_global_variable_and_write_node(node); end
-
-  # $foo += bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#634
-  def visit_global_variable_operator_write_node(node); end
-
-  # $foo ||= bar
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#646
-  def visit_global_variable_or_write_node(node); end
-
-  # $foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#619
-  def visit_global_variable_read_node(node); end
-
-  # $foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#652
-  def visit_global_variable_target_node(node); end
-
-  # $foo = 1
-  # ^^^^^^^^
-  #
-  # $foo, $bar = 1
-  # ^^^^  ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#628
-  def visit_global_variable_write_node(node); end
-
-  # {}
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#658
-  def visit_hash_node(node); end
-
-  # foo => {}
-  #        ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#664
-  def visit_hash_pattern_node(node); end
-
-  # if foo then bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar if foo
-  # ^^^^^^^^^^
-  #
-  # foo ? bar : baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#685
-  def visit_if_node(node); end
-
-  # 1i
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#690
-  def visit_imaginary_node(node); end
-
-  # { foo: }
-  #   ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#696
-  def visit_implicit_node(node); end
-
-  # foo { |bar,| }
-  #           ^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#701
-  def visit_implicit_rest_node(node); end
-
-  # case foo; in bar; end
-  # ^^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#706
-  def visit_in_node(node); end
-
-  # foo[bar] &&= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#732
-  def visit_index_and_write_node(node); end
-
-  # foo[bar] += baz
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#719
-  def visit_index_operator_write_node(node); end
-
-  # foo[bar] ||= baz
-  # ^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#745
-  def visit_index_or_write_node(node); end
-
-  # foo[bar], = 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#758
-  def visit_index_target_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#788
-  def visit_instance_variable_and_write_node(node); end
-
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#782
-  def visit_instance_variable_operator_write_node(node); end
-
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#794
-  def visit_instance_variable_or_write_node(node); end
-
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#767
-  def visit_instance_variable_read_node(node); end
-
-  # @foo, = bar
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#800
-  def visit_instance_variable_target_node(node); end
-
-  # ^^^^^^^^
-  #
-  # @foo, @bar = 1
-  # ^^^^  ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#776
-  def visit_instance_variable_write_node(node); end
-
-  # 1
-  # ^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#806
-  def visit_integer_node(node); end
-
-  # if /foo #{bar}/ then end
-  #    ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#812
-  def visit_interpolated_match_last_line_node(node); end
-
-  # /foo #{bar}/
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#829
-  def visit_interpolated_regular_expression_node(node); end
-
-  # "foo #{bar}"
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#844
-  def visit_interpolated_string_node(node); end
-
-  # :"foo #{bar}"
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#851
-  def visit_interpolated_symbol_node(node); end
-
-  # `foo #{bar}`
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#858
-  def visit_interpolated_x_string_node(node); end
-
-  # -> { it }
-  #      ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#923
-  def visit_it_local_variable_read_node(node); end
-
-  # foo(bar: baz)
-  #     ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#929
-  def visit_keyword_hash_node(node); end
-
-  # def foo(**bar); end
-  #         ^^^^^
-  #
-  # def foo(**); end
-  #         ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#938
-  def visit_keyword_rest_parameter_node(node); end
-
-  # -> {}
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#943
-  def visit_lambda_node(node); end
-
-  # foo &&= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#986
-  def visit_local_variable_and_write_node(node); end
-
-  # foo += bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#980
-  def visit_local_variable_operator_write_node(node); end
-
-  # foo ||= bar
-  # ^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#992
-  def visit_local_variable_or_write_node(node); end
-
-  # foo
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#961
-  def visit_local_variable_read_node(node); end
-
-  # foo, = bar
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#998
-  def visit_local_variable_target_node(node); end
-
-  # foo = 1
-  # ^^^^^^^
-  #
-  # foo, bar = 1
-  # ^^^  ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#974
-  def visit_local_variable_write_node(node); end
-
-  # if /foo/ then end
-  #    ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1004
-  def visit_match_last_line_node(node); end
-
-  # foo in bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1010
-  def visit_match_predicate_node(node); end
-
-  # foo => bar
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1016
-  def visit_match_required_node(node); end
-
-  # /(?<foo>foo)/ =~ bar
-  # ^^^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1022
-  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.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1029
-  def visit_missing_node(node); end
-
-  # module Foo; end
-  # ^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1035
-  def visit_module_node(node); end
-
-  # foo, bar = baz
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1055
-  def visit_multi_target_node(node); end
-
-  # foo, bar = baz
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1065
-  def visit_multi_write_node(node); end
-
-  # next
-  # ^^^^
-  #
-  # next foo
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1089
-  def visit_next_node(node); end
-
-  # nil
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1102
-  def visit_nil_node(node); end
-
-  # def foo(**nil); end
-  #         ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1108
-  def visit_no_keywords_parameter_node(node); end
-
-  # -> { _1 + _2 }
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1114
-  def visit_numbered_parameters_node(node); end
-
-  # $1
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1120
-  def visit_numbered_reference_read_node(node); end
-
-  # def foo(bar: baz); end
-  #         ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1126
-  def visit_optional_keyword_parameter_node(node); end
-
-  # def foo(bar = 1); end
-  #         ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1132
-  def visit_optional_parameter_node(node); end
-
-  # a or b
-  # ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1138
-  def visit_or_node(node); end
-
-  # def foo(bar, *baz); end
-  #         ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1144
-  def visit_parameters_node(node); end
-
-  # ()
-  # ^^
-  #
-  # (1)
-  # ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1182
-  def visit_parentheses_node(node); end
-
-  # foo => ^(bar)
-  #        ^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1192
-  def visit_pinned_expression_node(node); end
-
-  # foo = 1 and bar => ^foo
-  #                    ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1198
-  def visit_pinned_variable_node(node); end
-
-  # END {}
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1207
-  def visit_post_execution_node(node); end
-
-  # BEGIN {}
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1212
-  def visit_pre_execution_node(node); end
-
-  # The top-level program node.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1217
-  def visit_program_node(node); end
-
-  # 0..5
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1223
-  def visit_range_node(node); end
-
-  # 1r
-  # ^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1245
-  def visit_rational_node(node); end
-
-  # redo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1251
-  def visit_redo_node(node); end
-
-  # /foo/
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1257
-  def visit_regular_expression_node(node); end
-
-  # def foo(bar:); end
-  #         ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1263
-  def visit_required_keyword_parameter_node(node); end
-
-  # def foo(bar); end
-  #         ^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1269
-  def visit_required_parameter_node(node); end
-
-  # foo rescue bar
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1275
-  def visit_rescue_modifier_node(node); end
-
-  # begin; rescue; end
-  #        ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1281
-  def visit_rescue_node(node); end
-
-  # def foo(*bar); end
-  #         ^^^^
-  #
-  # def foo(*); end
-  #         ^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1301
-  def visit_rest_parameter_node(node); end
-
-  # retry
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1307
-  def visit_retry_node(node); end
-
-  # return
-  # ^^^^^^
-  #
-  # return 1
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1316
-  def visit_return_node(node); end
-
-  # self
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1329
-  def visit_self_node(node); end
-
-  # A shareable constant.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1334
-  def visit_shareable_constant_node(node); end
-
-  # class << self; end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1340
-  def visit_singleton_class_node(node); end
-
-  # __ENCODING__
-  # ^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1348
-  def visit_source_encoding_node(node); end
-
-  # __FILE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1355
-  def visit_source_file_node(node); end
-
-  # __LINE__
-  # ^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1361
-  def visit_source_line_node(node); end
-
-  # foo(*bar)
-  #     ^^^^
-  #
-  # def foo((bar, *baz)); end
-  #               ^^^^
-  #
-  # def foo(*); bar(*); end
-  #                 ^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1373
-  def visit_splat_node(node); end
-
-  # A list of statements.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1382
-  def visit_statements_node(node); end
-
-  # "foo"
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1394
-  def visit_string_node(node); end
-
-  # super(foo)
-  # ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1400
-  def visit_super_node(node); end
-
-  # :foo
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1414
-  def visit_symbol_node(node); end
-
-  # true
-  # ^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1420
-  def visit_true_node(node); end
-
-  # undef foo
-  # ^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1426
-  def visit_undef_node(node); end
-
-  # unless foo; bar end
-  # ^^^^^^^^^^^^^^^^^^^
-  #
-  # bar unless foo
-  # ^^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1436
-  def visit_unless_node(node); end
-
-  # until foo; bar end
-  # ^^^^^^^^^^^^^^^^^
-  #
-  # bar until foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1445
-  def visit_until_node(node); end
-
-  # case foo; when bar; end
-  #           ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1451
-  def visit_when_node(node); end
-
-  # while foo; bar end
-  # ^^^^^^^^^^^^^^^^^^
-  #
-  # bar while foo
-  # ^^^^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1460
-  def visit_while_node(node); end
-
-  # `foo`
-  # ^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1466
-  def visit_x_string_node(node); end
-
-  # yield
-  # ^^^^^
-  #
-  # yield 1
-  # ^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1482
-  def visit_yield_node(node); end
-
-  private
-
-  # If a class variable is written within a method definition, it has a
-  # different type than everywhere else.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#403
-  def class_variable_write_type; end
-
-  # Create a new compiler with the given options.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1489
-  def copy_compiler(in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
-
-  # Call nodes with operators following them will either be op_asgn or
-  # op_asgn2 nodes. That is determined by their call operator and their
-  # right-hand side.
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#308
-  def op_asgn?(node); end
-
-  # Call nodes with operators following them can use &. as an operator,
-  # which changes their type by prefixing "safe_".
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#314
-  def op_asgn_type(node, type); end
-
-  # Create a new Sexp object from the given prism node and arguments.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1494
-  def s(node, *arguments); end
-
-  # Visit a block node, which will modify the AST by wrapping the given
-  # visited node in an iter node.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1504
-  def visit_block(node, sexp, block); end
-
-  # def foo((bar, baz)); end
-  #         ^^^^^^^^^^
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1159
-  def visit_destructured_parameter(node); end
-
-  # Visit the interpolated content of the string-like node.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#865
-  def visit_interpolated_parts(parts); end
-
-  # Pattern constants get wrapped in another layer of :const.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1525
-  def visit_pattern_constant(node); end
-
-  # If the bounds of a range node are empty parentheses, then they do not
-  # get replaced by their usual s(:nil), but instead are s(:begin).
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1235
-  def visit_range_bounds_node(node); end
-
-  # Visit the value of a write, which will be on the right-hand side of
-  # a write operator. Because implicit arrays can have splats, those could
-  # potentially be wrapped in an svalue node.
-  #
-  # source://prism//lib/prism/translation/ruby_parser.rb#1539
-  def visit_write_value(node); end
-end
-
-# Represents the use of the literal `true` keyword.
-#
-#     true
-#     ^^^^
-#
-# source://prism//lib/prism/node.rb#18041
-class Prism::TrueNode < ::Prism::Node
-  # def initialize: (Location location) -> void
-  #
-  # @return [TrueNode] a new instance of TrueNode
-  #
-  # source://prism//lib/prism/node.rb#18043
-  sig { params(source: Prism::Source, location: Prism::Location).void }
-  def initialize(source, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18116
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18049
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18054
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18064
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18059
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?location: Location) -> TrueNode
-  #
-  # source://prism//lib/prism/node.rb#18069
-  sig { params(location: Prism::Location).returns(Prism::TrueNode) }
-  def copy(location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18054
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18077
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18082
-  sig { override.returns(String) }
-  def inspect; end
-
-  # Sometimes you want to check an instance of a node against a list of
-  # classes to see what kind of behavior to perform. Usually this is done by
-  # calling `[cls1, cls2].include?(node.class)` or putting the node into a
-  # case statement and doing `case node; when cls1; when cls2; end`. Both of
-  # these approaches are relatively slow because of the constant lookups,
-  # method calls, and/or array allocations.
-  #
-  # Instead, you can call #type, which will return to you a symbol that you
-  # can use for comparison. This is faster than the other approaches because
-  # it uses a single integer comparison, but also because if you're on CRuby
-  # you can take advantage of the fact that case statements with all symbol
-  # keys will use a jump table.
-  #
-  # def type: () -> Symbol
-  #
-  # source://prism//lib/prism/node.rb#18100
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#18110
-    def type; end
-  end
-end
-
-# Represents the use of the `undef` keyword.
-#
-#     undef :foo, :bar, :baz
-#     ^^^^^^^^^^^^^^^^^^^^^^
-#
-# source://prism//lib/prism/node.rb#18125
-class Prism::UndefNode < ::Prism::Node
-  # def initialize: (Array[SymbolNode | InterpolatedSymbolNode] names, Location keyword_loc, Location location) -> void
-  #
-  # @return [UndefNode] a new instance of UndefNode
-  #
-  # source://prism//lib/prism/node.rb#18127
-  sig do
-    params(
-      source: Prism::Source,
-      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, names, keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18217
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18135
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18140
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18150
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18145
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location, ?location: Location) -> UndefNode
-  #
-  # source://prism//lib/prism/node.rb#18155
-  sig do
-    params(
-      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
-      keyword_loc: Prism::Location,
-      location: Prism::Location
-    ).returns(Prism::UndefNode)
-  end
-  def copy(names: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18140
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18163
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18183
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18178
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18171
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
-  #
-  # source://prism//lib/prism/node.rb#18168
-  sig { returns(T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) }
-  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//lib/prism/node.rb#18201
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#18211
-    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//lib/prism/node.rb#18232
-class Prism::UnlessNode < ::Prism::Node
-  # def initialize: (Location keyword_loc, Prism::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//lib/prism/node.rb#18234
-  sig do
-    params(
-      source: Prism::Source,
-      keyword_loc: Prism::Location,
-      predicate: Prism::Node,
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::ElseNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18399
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18246
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18251
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18265
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18256
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # The else clause of the unless expression, if present.
-  #
-  #     unless cond then bar else baz end
-  #                          ^^^^^^^^
-  #
-  # source://prism//lib/prism/node.rb#18331
-  sig { returns(T.nilable(Prism::ElseNode)) }
-  def consequent; end
-
-  # def copy: (?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: ElseNode?, ?end_keyword_loc: Location?, ?location: Location) -> UnlessNode
-  #
-  # source://prism//lib/prism/node.rb#18270
-  sig do
-    params(
-      keyword_loc: Prism::Location,
-      predicate: Prism::Node,
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      consequent: T.nilable(Prism::ElseNode),
-      end_keyword_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::UnlessNode)
-  end
-  def copy(keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18251
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18278
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  # def end_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#18360
-  sig { returns(T.nilable(String)) }
-  def end_keyword; end
-
-  # The location of the `end` keyword, if present.
-  #
-  #     unless cond then bar end
-  #                          ^^^
-  #
-  # source://prism//lib/prism/node.rb#18337
-  sig { returns(T.nilable(Prism::Location)) }
-  def end_keyword_loc; end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18365
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18350
-  sig { returns(String) }
-  def keyword; end
-
-  # The location of the `unless` keyword.
-  #
-  #     unless cond then bar end
-  #     ^^^^^^
-  #
-  #     bar unless cond
-  #         ^^^^^^
-  #
-  # source://prism//lib/prism/node.rb#18289
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#97
-  def newline!(lines); end
-
-  # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
-  #
-  #     unless cond then bar end
-  #            ^^^^
-  #
-  #     bar unless cond
-  #                ^^^^
-  #
-  # source://prism//lib/prism/node.rb#18302
-  sig { returns(Prism::Node) }
-  def predicate; end
-
-  # The body of statements that will executed if the unless condition is
-  # falsey. Will be `nil` if no body is provided.
-  #
-  #     unless cond then bar end
-  #                      ^^^
-  #
-  # source://prism//lib/prism/node.rb#18325
-  sig { returns(T.nilable(Prism::StatementsNode)) }
-  def statements; end
-
-  # def then_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#18355
-  sig { returns(T.nilable(String)) }
-  def then_keyword; end
-
-  # The location of the `then` keyword, if present.
-  #
-  #     unless cond then bar end
-  #                 ^^^^
-  #
-  # source://prism//lib/prism/node.rb#18308
-  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//lib/prism/node.rb#18383
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#18393
-    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//lib/prism/node.rb#18417
-class Prism::UntilNode < ::Prism::Node
-  # def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
-  #
-  # @return [UntilNode] a new instance of UntilNode
-  #
-  # source://prism//lib/prism/node.rb#18419
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18545
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18430
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def begin_modifier?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#18496
-  sig { returns(T::Boolean) }
-  def begin_modifier?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18435
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#18506
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#18477
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18448
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18440
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> UntilNode
-  #
-  # source://prism//lib/prism/node.rb#18453
-  sig do
-    params(
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).returns(Prism::UntilNode)
-  end
-  def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18435
-  sig { override.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: Prism::node, statements: StatementsNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18461
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18511
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18501
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18470
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#103
-  def newline!(lines); end
-
-  # attr_reader predicate: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#18490
-  sig { returns(Prism::Node) }
-  def predicate; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#18493
-  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//lib/prism/node.rb#18529
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#18466
-  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//lib/prism/node.rb#18539
-    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//lib/prism/visitor.rb#54
-class Prism::Visitor < ::Prism::BasicVisitor
-  # Visit a AliasGlobalVariableNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AliasGlobalVariableNode).void }
-  def visit_alias_global_variable_node(node); end
-
-  # Visit a AliasMethodNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AliasMethodNode).void }
-  def visit_alias_method_node(node); end
-
-  # Visit a AlternationPatternNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AlternationPatternNode).void }
-  def visit_alternation_pattern_node(node); end
-
-  # Visit a AndNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AndNode).void }
-  def visit_and_node(node); end
-
-  # Visit a ArgumentsNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ArgumentsNode).void }
-  def visit_arguments_node(node); end
-
-  # Visit a ArrayNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ArrayNode).void }
-  def visit_array_node(node); end
-
-  # Visit a ArrayPatternNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ArrayPatternNode).void }
-  def visit_array_pattern_node(node); end
-
-  # Visit a AssocNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AssocNode).void }
-  def visit_assoc_node(node); end
-
-  # Visit a AssocSplatNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::AssocSplatNode).void }
-  def visit_assoc_splat_node(node); end
-
-  # Visit a BackReferenceReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BackReferenceReadNode).void }
-  def visit_back_reference_read_node(node); end
-
-  # Visit a BeginNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BeginNode).void }
-  def visit_begin_node(node); end
-
-  # Visit a BlockArgumentNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BlockArgumentNode).void }
-  def visit_block_argument_node(node); end
-
-  # Visit a BlockLocalVariableNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BlockLocalVariableNode).void }
-  def visit_block_local_variable_node(node); end
-
-  # Visit a BlockNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BlockNode).void }
-  def visit_block_node(node); end
-
-  # Visit a BlockParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BlockParameterNode).void }
-  def visit_block_parameter_node(node); end
-
-  # Visit a BlockParametersNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BlockParametersNode).void }
-  def visit_block_parameters_node(node); end
-
-  # Visit a BreakNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::BreakNode).void }
-  def visit_break_node(node); end
-
-  # Visit a CallAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CallAndWriteNode).void }
-  def visit_call_and_write_node(node); end
-
-  # Visit a CallNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CallNode).void }
-  def visit_call_node(node); end
-
-  # Visit a CallOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CallOperatorWriteNode).void }
-  def visit_call_operator_write_node(node); end
-
-  # Visit a CallOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CallOrWriteNode).void }
-  def visit_call_or_write_node(node); end
-
-  # Visit a CallTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CallTargetNode).void }
-  def visit_call_target_node(node); end
-
-  # Visit a CapturePatternNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CapturePatternNode).void }
-  def visit_capture_pattern_node(node); end
-
-  # Visit a CaseMatchNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CaseMatchNode).void }
-  def visit_case_match_node(node); end
-
-  # Visit a CaseNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::CaseNode).void }
-  def visit_case_node(node); end
-
-  # Visit a ClassNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassNode).void }
-  def visit_class_node(node); end
-
-  # Visit a ClassVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableAndWriteNode).void }
-  def visit_class_variable_and_write_node(node); end
-
-  # Visit a ClassVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
-  def visit_class_variable_operator_write_node(node); end
-
-  # Visit a ClassVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableOrWriteNode).void }
-  def visit_class_variable_or_write_node(node); end
-
-  # Visit a ClassVariableReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableReadNode).void }
-  def visit_class_variable_read_node(node); end
-
-  # Visit a ClassVariableTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableTargetNode).void }
-  def visit_class_variable_target_node(node); end
-
-  # Visit a ClassVariableWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ClassVariableWriteNode).void }
-  def visit_class_variable_write_node(node); end
-
-  # Visit a ConstantAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantAndWriteNode).void }
-  def visit_constant_and_write_node(node); end
-
-  # Visit a ConstantOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantOperatorWriteNode).void }
-  def visit_constant_operator_write_node(node); end
-
-  # Visit a ConstantOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantOrWriteNode).void }
-  def visit_constant_or_write_node(node); end
-
-  # Visit a ConstantPathAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathAndWriteNode).void }
-  def visit_constant_path_and_write_node(node); end
-
-  # Visit a ConstantPathNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathNode).void }
-  def visit_constant_path_node(node); end
-
-  # Visit a ConstantPathOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
-  def visit_constant_path_operator_write_node(node); end
-
-  # Visit a ConstantPathOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathOrWriteNode).void }
-  def visit_constant_path_or_write_node(node); end
-
-  # Visit a ConstantPathTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathTargetNode).void }
-  def visit_constant_path_target_node(node); end
-
-  # Visit a ConstantPathWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantPathWriteNode).void }
-  def visit_constant_path_write_node(node); end
-
-  # Visit a ConstantReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantReadNode).void }
-  def visit_constant_read_node(node); end
-
-  # Visit a ConstantTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantTargetNode).void }
-  def visit_constant_target_node(node); end
-
-  # Visit a ConstantWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ConstantWriteNode).void }
-  def visit_constant_write_node(node); end
-
-  # Visit a DefNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::DefNode).void }
-  def visit_def_node(node); end
-
-  # Visit a DefinedNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::DefinedNode).void }
-  def visit_defined_node(node); end
-
-  # Visit a ElseNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ElseNode).void }
-  def visit_else_node(node); end
-
-  # Visit a EmbeddedStatementsNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::EmbeddedStatementsNode).void }
-  def visit_embedded_statements_node(node); end
-
-  # Visit a EmbeddedVariableNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::EmbeddedVariableNode).void }
-  def visit_embedded_variable_node(node); end
-
-  # Visit a EnsureNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::EnsureNode).void }
-  def visit_ensure_node(node); end
-
-  # Visit a FalseNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::FalseNode).void }
-  def visit_false_node(node); end
-
-  # Visit a FindPatternNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::FindPatternNode).void }
-  def visit_find_pattern_node(node); end
-
-  # Visit a FlipFlopNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::FlipFlopNode).void }
-  def visit_flip_flop_node(node); end
-
-  # Visit a FloatNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::FloatNode).void }
-  def visit_float_node(node); end
-
-  # Visit a ForNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ForNode).void }
-  def visit_for_node(node); end
-
-  # Visit a ForwardingArgumentsNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ForwardingArgumentsNode).void }
-  def visit_forwarding_arguments_node(node); end
-
-  # Visit a ForwardingParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ForwardingParameterNode).void }
-  def visit_forwarding_parameter_node(node); end
-
-  # Visit a ForwardingSuperNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ForwardingSuperNode).void }
-  def visit_forwarding_super_node(node); end
-
-  # Visit a GlobalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableAndWriteNode).void }
-  def visit_global_variable_and_write_node(node); end
-
-  # Visit a GlobalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
-  def visit_global_variable_operator_write_node(node); end
-
-  # Visit a GlobalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableOrWriteNode).void }
-  def visit_global_variable_or_write_node(node); end
-
-  # Visit a GlobalVariableReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableReadNode).void }
-  def visit_global_variable_read_node(node); end
-
-  # Visit a GlobalVariableTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableTargetNode).void }
-  def visit_global_variable_target_node(node); end
-
-  # Visit a GlobalVariableWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::GlobalVariableWriteNode).void }
-  def visit_global_variable_write_node(node); end
-
-  # Visit a HashNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::HashNode).void }
-  def visit_hash_node(node); end
-
-  # Visit a HashPatternNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::HashPatternNode).void }
-  def visit_hash_pattern_node(node); end
-
-  # Visit a IfNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IfNode).void }
-  def visit_if_node(node); end
-
-  # Visit a ImaginaryNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ImaginaryNode).void }
-  def visit_imaginary_node(node); end
-
-  # Visit a ImplicitNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ImplicitNode).void }
-  def visit_implicit_node(node); end
-
-  # Visit a ImplicitRestNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ImplicitRestNode).void }
-  def visit_implicit_rest_node(node); end
-
-  # Visit a InNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InNode).void }
-  def visit_in_node(node); end
-
-  # Visit a IndexAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IndexAndWriteNode).void }
-  def visit_index_and_write_node(node); end
-
-  # Visit a IndexOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IndexOperatorWriteNode).void }
-  def visit_index_operator_write_node(node); end
-
-  # Visit a IndexOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IndexOrWriteNode).void }
-  def visit_index_or_write_node(node); end
-
-  # Visit a IndexTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IndexTargetNode).void }
-  def visit_index_target_node(node); end
-
-  # Visit a InstanceVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableAndWriteNode).void }
-  def visit_instance_variable_and_write_node(node); end
-
-  # Visit a InstanceVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
-  def visit_instance_variable_operator_write_node(node); end
-
-  # Visit a InstanceVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableOrWriteNode).void }
-  def visit_instance_variable_or_write_node(node); end
-
-  # Visit a InstanceVariableReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableReadNode).void }
-  def visit_instance_variable_read_node(node); end
-
-  # Visit a InstanceVariableTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableTargetNode).void }
-  def visit_instance_variable_target_node(node); end
-
-  # Visit a InstanceVariableWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InstanceVariableWriteNode).void }
-  def visit_instance_variable_write_node(node); end
-
-  # Visit a IntegerNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::IntegerNode).void }
-  def visit_integer_node(node); end
-
-  # Visit a InterpolatedMatchLastLineNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InterpolatedMatchLastLineNode).void }
-  def visit_interpolated_match_last_line_node(node); end
-
-  # Visit a InterpolatedRegularExpressionNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InterpolatedRegularExpressionNode).void }
-  def visit_interpolated_regular_expression_node(node); end
-
-  # Visit a InterpolatedStringNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InterpolatedStringNode).void }
-  def visit_interpolated_string_node(node); end
-
-  # Visit a InterpolatedSymbolNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InterpolatedSymbolNode).void }
-  def visit_interpolated_symbol_node(node); end
-
-  # Visit a InterpolatedXStringNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::InterpolatedXStringNode).void }
-  def visit_interpolated_x_string_node(node); end
-
-  # Visit a ItLocalVariableReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ItLocalVariableReadNode).void }
-  def visit_it_local_variable_read_node(node); end
-
-  # Visit a ItParametersNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ItParametersNode).void }
-  def visit_it_parameters_node(node); end
-
-  # Visit a KeywordHashNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::KeywordHashNode).void }
-  def visit_keyword_hash_node(node); end
-
-  # Visit a KeywordRestParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::KeywordRestParameterNode).void }
-  def visit_keyword_rest_parameter_node(node); end
-
-  # Visit a LambdaNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LambdaNode).void }
-  def visit_lambda_node(node); end
-
-  # Visit a LocalVariableAndWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableAndWriteNode).void }
-  def visit_local_variable_and_write_node(node); end
-
-  # Visit a LocalVariableOperatorWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
-  def visit_local_variable_operator_write_node(node); end
-
-  # Visit a LocalVariableOrWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableOrWriteNode).void }
-  def visit_local_variable_or_write_node(node); end
-
-  # Visit a LocalVariableReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableReadNode).void }
-  def visit_local_variable_read_node(node); end
-
-  # Visit a LocalVariableTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableTargetNode).void }
-  def visit_local_variable_target_node(node); end
-
-  # Visit a LocalVariableWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::LocalVariableWriteNode).void }
-  def visit_local_variable_write_node(node); end
-
-  # Visit a MatchLastLineNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MatchLastLineNode).void }
-  def visit_match_last_line_node(node); end
-
-  # Visit a MatchPredicateNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MatchPredicateNode).void }
-  def visit_match_predicate_node(node); end
-
-  # Visit a MatchRequiredNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MatchRequiredNode).void }
-  def visit_match_required_node(node); end
-
-  # Visit a MatchWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MatchWriteNode).void }
-  def visit_match_write_node(node); end
-
-  # Visit a MissingNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MissingNode).void }
-  def visit_missing_node(node); end
-
-  # Visit a ModuleNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ModuleNode).void }
-  def visit_module_node(node); end
-
-  # Visit a MultiTargetNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MultiTargetNode).void }
-  def visit_multi_target_node(node); end
-
-  # Visit a MultiWriteNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::MultiWriteNode).void }
-  def visit_multi_write_node(node); end
-
-  # Visit a NextNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::NextNode).void }
-  def visit_next_node(node); end
-
-  # Visit a NilNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::NilNode).void }
-  def visit_nil_node(node); end
-
-  # Visit a NoKeywordsParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::NoKeywordsParameterNode).void }
-  def visit_no_keywords_parameter_node(node); end
-
-  # Visit a NumberedParametersNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::NumberedParametersNode).void }
-  def visit_numbered_parameters_node(node); end
-
-  # Visit a NumberedReferenceReadNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::NumberedReferenceReadNode).void }
-  def visit_numbered_reference_read_node(node); end
-
-  # Visit a OptionalKeywordParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::OptionalKeywordParameterNode).void }
-  def visit_optional_keyword_parameter_node(node); end
-
-  # Visit a OptionalParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::OptionalParameterNode).void }
-  def visit_optional_parameter_node(node); end
-
-  # Visit a OrNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::OrNode).void }
-  def visit_or_node(node); end
-
-  # Visit a ParametersNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ParametersNode).void }
-  def visit_parameters_node(node); end
-
-  # Visit a ParenthesesNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ParenthesesNode).void }
-  def visit_parentheses_node(node); end
-
-  # Visit a PinnedExpressionNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::PinnedExpressionNode).void }
-  def visit_pinned_expression_node(node); end
-
-  # Visit a PinnedVariableNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::PinnedVariableNode).void }
-  def visit_pinned_variable_node(node); end
-
-  # Visit a PostExecutionNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::PostExecutionNode).void }
-  def visit_post_execution_node(node); end
-
-  # Visit a PreExecutionNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::PreExecutionNode).void }
-  def visit_pre_execution_node(node); end
-
-  # Visit a ProgramNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ProgramNode).void }
-  def visit_program_node(node); end
-
-  # Visit a RangeNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RangeNode).void }
-  def visit_range_node(node); end
-
-  # Visit a RationalNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RationalNode).void }
-  def visit_rational_node(node); end
-
-  # Visit a RedoNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RedoNode).void }
-  def visit_redo_node(node); end
-
-  # Visit a RegularExpressionNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RegularExpressionNode).void }
-  def visit_regular_expression_node(node); end
-
-  # Visit a RequiredKeywordParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RequiredKeywordParameterNode).void }
-  def visit_required_keyword_parameter_node(node); end
-
-  # Visit a RequiredParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RequiredParameterNode).void }
-  def visit_required_parameter_node(node); end
-
-  # Visit a RescueModifierNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RescueModifierNode).void }
-  def visit_rescue_modifier_node(node); end
-
-  # Visit a RescueNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RescueNode).void }
-  def visit_rescue_node(node); end
-
-  # Visit a RestParameterNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RestParameterNode).void }
-  def visit_rest_parameter_node(node); end
-
-  # Visit a RetryNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::RetryNode).void }
-  def visit_retry_node(node); end
-
-  # Visit a ReturnNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ReturnNode).void }
-  def visit_return_node(node); end
-
-  # Visit a SelfNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SelfNode).void }
-  def visit_self_node(node); end
-
-  # Visit a ShareableConstantNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::ShareableConstantNode).void }
-  def visit_shareable_constant_node(node); end
-
-  # Visit a SingletonClassNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SingletonClassNode).void }
-  def visit_singleton_class_node(node); end
-
-  # Visit a SourceEncodingNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SourceEncodingNode).void }
-  def visit_source_encoding_node(node); end
-
-  # Visit a SourceFileNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SourceFileNode).void }
-  def visit_source_file_node(node); end
-
-  # Visit a SourceLineNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SourceLineNode).void }
-  def visit_source_line_node(node); end
-
-  # Visit a SplatNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SplatNode).void }
-  def visit_splat_node(node); end
-
-  # Visit a StatementsNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::StatementsNode).void }
-  def visit_statements_node(node); end
-
-  # Visit a StringNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::StringNode).void }
-  def visit_string_node(node); end
-
-  # Visit a SuperNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SuperNode).void }
-  def visit_super_node(node); end
-
-  # Visit a SymbolNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::SymbolNode).void }
-  def visit_symbol_node(node); end
-
-  # Visit a TrueNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::TrueNode).void }
-  def visit_true_node(node); end
-
-  # Visit a UndefNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::UndefNode).void }
-  def visit_undef_node(node); end
-
-  # Visit a UnlessNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::UnlessNode).void }
-  def visit_unless_node(node); end
-
-  # Visit a UntilNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::UntilNode).void }
-  def visit_until_node(node); end
-
-  # Visit a WhenNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::WhenNode).void }
-  def visit_when_node(node); end
-
-  # Visit a WhileNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::WhileNode).void }
-  def visit_while_node(node); end
-
-  # Visit a XStringNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::XStringNode).void }
-  def visit_x_string_node(node); end
-
-  # Visit a YieldNode node
-  #
-  # source://prism//lib/prism/visitor.rb#29
-  sig { params(node: Prism::YieldNode).void }
-  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//lib/prism/node.rb#18561
-class Prism::WhenNode < ::Prism::Node
-  # def initialize: (Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements, Location location) -> void
-  #
-  # @return [WhenNode] a new instance of WhenNode
-  #
-  # source://prism//lib/prism/node.rb#18563
-  sig do
-    params(
-      source: Prism::Source,
-      keyword_loc: Prism::Location,
-      conditions: T::Array[Prism::Node],
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, keyword_loc, conditions, then_keyword_loc, statements, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18679
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18573
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18578
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18591
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18583
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # attr_reader conditions: Array[Prism::node]
-  #
-  # source://prism//lib/prism/node.rb#18616
-  sig { returns(T::Array[Prism::Node]) }
-  def conditions; end
-
-  # def copy: (?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?location: Location) -> WhenNode
-  #
-  # source://prism//lib/prism/node.rb#18596
-  sig do
-    params(
-      keyword_loc: Prism::Location,
-      conditions: T::Array[Prism::Node],
-      then_keyword_loc: T.nilable(Prism::Location),
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).returns(Prism::WhenNode)
-  end
-  def copy(keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18578
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def deconstruct; end
-
-  # def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18604
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18645
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18635
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18609
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#18632
-  sig { returns(T.nilable(Prism::StatementsNode)) }
-  def statements; end
-
-  # def then_keyword: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#18640
-  sig { returns(T.nilable(String)) }
-  def then_keyword; end
-
-  # attr_reader then_keyword_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#18619
-  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//lib/prism/node.rb#18663
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#18673
-    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//lib/prism/node.rb#18696
-class Prism::WhileNode < ::Prism::Node
-  # def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
-  #
-  # @return [WhileNode] a new instance of WhileNode
-  #
-  # source://prism//lib/prism/node.rb#18698
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18824
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18709
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def begin_modifier?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#18775
-  sig { returns(T::Boolean) }
-  def begin_modifier?; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18714
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#18785
-  sig { returns(T.nilable(String)) }
-  def closing; end
-
-  # attr_reader closing_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#18756
-  sig { returns(T.nilable(Prism::Location)) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18727
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18719
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> WhileNode
-  #
-  # source://prism//lib/prism/node.rb#18732
-  sig do
-    params(
-      flags: Integer,
-      keyword_loc: Prism::Location,
-      closing_loc: T.nilable(Prism::Location),
-      predicate: Prism::Node,
-      statements: T.nilable(Prism::StatementsNode),
-      location: Prism::Location
-    ).returns(Prism::WhileNode)
-  end
-  def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18714
-  sig { override.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: Prism::node, statements: StatementsNode?, location: Location }
-  #
-  # source://prism//lib/prism/node.rb#18740
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18790
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18780
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18749
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # source://prism//lib/prism/parse_result/newlines.rb#109
-  def newline!(lines); end
-
-  # attr_reader predicate: Prism::node
-  #
-  # source://prism//lib/prism/node.rb#18769
-  sig { returns(Prism::Node) }
-  def predicate; end
-
-  # attr_reader statements: StatementsNode?
-  #
-  # source://prism//lib/prism/node.rb#18772
-  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//lib/prism/node.rb#18808
-  sig { override.returns(Symbol) }
-  def type; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#18745
-  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//lib/prism/node.rb#18818
-    def type; end
-  end
-end
-
-# Represents an xstring literal with no interpolation.
-#
-#     `foo`
-#     ^^^^^
-#
-# source://prism//lib/prism/node.rb#18838
-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//lib/prism/node.rb#18840
-  sig do
-    params(
-      source: Prism::Source,
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#18971
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18851
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18856
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def closing: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18932
-  sig { returns(String) }
-  def closing; end
-
-  # attr_reader closing_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18902
-  sig { returns(Prism::Location) }
-  def closing_loc; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#18866
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#18861
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def content: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18927
-  sig { returns(String) }
-  def content; end
-
-  # attr_reader content_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18895
-  sig { returns(Prism::Location) }
-  def content_loc; end
-
-  # def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> XStringNode
-  #
-  # source://prism//lib/prism/node.rb#18871
-  sig do
-    params(
-      flags: Integer,
-      opening_loc: Prism::Location,
-      content_loc: Prism::Location,
-      closing_loc: Prism::Location,
-      unescaped: String,
-      location: Prism::Location
-    ).returns(Prism::XStringNode)
-  end
-  def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#18856
-  sig { override.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//lib/prism/node.rb#18879
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def forced_binary_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#18917
-  sig { returns(T::Boolean) }
-  def forced_binary_encoding?; end
-
-  # def forced_utf8_encoding?: () -> bool
-  #
-  # @return [Boolean]
-  #
-  # source://prism//lib/prism/node.rb#18912
-  sig { returns(T::Boolean) }
-  def forced_utf8_encoding?; end
-
-  sig { returns(T::Boolean) }
-  def heredoc?; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#18937
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def opening: () -> String
-  #
-  # source://prism//lib/prism/node.rb#18922
-  sig { returns(String) }
-  def opening; end
-
-  # attr_reader opening_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#18888
-  sig { returns(Prism::Location) }
-  def opening_loc; end
-
-  # Occasionally it's helpful to treat a string as if it were interpolated so
-  # that there's a consistent interface for working with strings.
-  #
-  # source://prism//lib/prism/node_ext.rb#86
-  sig { returns(Prism::InterpolatedXStringNode) }
-  def to_interpolated; 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//lib/prism/node.rb#18955
-  sig { override.returns(Symbol) }
-  def type; end
-
-  # attr_reader unescaped: String
-  #
-  # source://prism//lib/prism/node.rb#18909
-  sig { returns(String) }
-  def unescaped; end
-
-  protected
-
-  # protected attr_reader flags: Integer
-  #
-  # source://prism//lib/prism/node.rb#18884
-  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//lib/prism/node.rb#18965
-    def type; end
-  end
-end
-
-# Represents the use of the `yield` keyword.
-#
-#     yield 1
-#     ^^^^^^^
-#
-# source://prism//lib/prism/node.rb#18985
-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//lib/prism/node.rb#18987
-  sig do
-    params(
-      source: Prism::Source,
-      keyword_loc: Prism::Location,
-      lparen_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      rparen_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).void
-  end
-  def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, location); end
-
-  # Implements case-equality for the node. This is effectively == but without
-  # comparing the value of locations. Locations are checked only for presence.
-  #
-  # source://prism//lib/prism/node.rb#19117
-  def ===(other); end
-
-  # def accept: (Visitor visitor) -> void
-  #
-  # source://prism//lib/prism/node.rb#18997
-  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
-  def accept(visitor); end
-
-  # attr_reader arguments: ArgumentsNode?
-  #
-  # source://prism//lib/prism/node.rb#19052
-  sig { returns(T.nilable(Prism::ArgumentsNode)) }
-  def arguments; end
-
-  # def child_nodes: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#19002
-  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
-  def child_nodes; end
-
-  # def comment_targets: () -> Array[Node | Location]
-  #
-  # source://prism//lib/prism/node.rb#19014
-  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
-  def comment_targets; end
-
-  # def compact_child_nodes: () -> Array[Node]
-  #
-  # source://prism//lib/prism/node.rb#19007
-  sig { override.returns(T::Array[Prism::Node]) }
-  def compact_child_nodes; end
-
-  # def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?location: Location) -> YieldNode
-  #
-  # source://prism//lib/prism/node.rb#19019
-  sig do
-    params(
-      keyword_loc: Prism::Location,
-      lparen_loc: T.nilable(Prism::Location),
-      arguments: T.nilable(Prism::ArgumentsNode),
-      rparen_loc: T.nilable(Prism::Location),
-      location: Prism::Location
-    ).returns(Prism::YieldNode)
-  end
-  def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
-
-  # def child_nodes: () -> Array[nil | Node]
-  # def deconstruct: () -> Array[nil | Node]
-  #
-  # source://prism//lib/prism/node.rb#19002
-  sig { override.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//lib/prism/node.rb#19027
-  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
-  def deconstruct_keys(keys); end
-
-  sig { override.returns(T::Array[Prism::Reflection::Field]) }
-  def fields; end
-
-  # def inspect -> String
-  #
-  # source://prism//lib/prism/node.rb#19083
-  sig { override.returns(String) }
-  def inspect; end
-
-  # def keyword: () -> String
-  #
-  # source://prism//lib/prism/node.rb#19068
-  sig { returns(String) }
-  def keyword; end
-
-  # attr_reader keyword_loc: Location
-  #
-  # source://prism//lib/prism/node.rb#19032
-  sig { returns(Prism::Location) }
-  def keyword_loc; end
-
-  # def lparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#19073
-  sig { returns(T.nilable(String)) }
-  def lparen; end
-
-  # attr_reader lparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#19039
-  sig { returns(T.nilable(Prism::Location)) }
-  def lparen_loc; end
-
-  # def rparen: () -> String?
-  #
-  # source://prism//lib/prism/node.rb#19078
-  sig { returns(T.nilable(String)) }
-  def rparen; end
-
-  # attr_reader rparen_loc: Location?
-  #
-  # source://prism//lib/prism/node.rb#19055
-  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//lib/prism/node.rb#19101
-  sig { override.returns(Symbol) }
-  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//lib/prism/node.rb#19111
-    def type; end
-  end
-end
diff --git a/sorbet/rbi/gems/prism@1.0.0.rbi b/sorbet/rbi/gems/prism@1.0.0.rbi
new file mode 100644
index 0000000..a476ea8
--- /dev/null
+++ b/sorbet/rbi/gems/prism@1.0.0.rbi
@@ -0,0 +1,24255 @@
+# 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`.
+
+
+# typed: strict
+
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/dsl.rbi.erb
+# if you are looking to modify the template
+# =end
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/node.rbi.erb
+# if you are looking to modify the template
+# =end
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism/visitor.rbi.erb
+# if you are looking to modify the template
+# =end
+
+# We keep these shims in here because our client libraries might not have parser
+# in their bundle.
+module Parser; end
+
+class Parser::Base; end
+
+# The Prism Ruby parser.
+#
+# "Parsing Ruby is suddenly manageable!"
+#   - You, hopefully
+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) -> LexCompat::Result
+    #
+    # 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.
+    sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
+    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.
+    sig { params(source: String).returns(T::Array[T.untyped]) }
+    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.
+    sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
+    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
+
+    # Mirror the Prism.parse_failure? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_failure?(*_arg0); 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
+
+    # Mirror the Prism.parse_file_failure? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_file_failure?(*_arg0); 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_stream API by using the serialization API.
+    def parse_stream(*_arg0); end
+
+    # Mirror the Prism.parse_success? API by using the serialization API.
+    #
+    # @return [Boolean]
+    def parse_success?(*_arg0); end
+
+    # Mirror the Prism.profile API by using the serialization API.
+    def profile(*_arg0); end
+
+    # Mirror the Prism.profile_file API by using the serialization API.
+    def profile_file(*_arg0); end
+  end
+end
+
+# Specialized version of Prism::Source for source code that includes ASCII
+# characters only. This class is used to apply performance optimizations that
+# cannot be applied to sources that include multibyte characters. Sources that
+# include multibyte characters are represented by the Prism::Source class.
+class Prism::ASCIISource < ::Prism::Source
+  # Return the column number in characters for the given byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_column(byte_offset); end
+
+  # Return the character offset for the given byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_offset(byte_offset); end
+
+  # Specialized version of `code_units_column` that does not depend on
+  # `code_units_offset`, which is a more expensive operation. This is
+  # essentialy the same as `Prism::Source#column`.
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_column(byte_offset, encoding); end
+
+  # Returns the offset from the start of the file for the given byte offset
+  # counting in code units for the given encoding.
+  #
+  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
+  # concept of code units that differs from the number of characters in other
+  # encodings, it is not captured here.
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_offset(byte_offset, encoding); end
+end
+
+# Represents the use of the `alias` keyword to alias a global variable.
+#
+#     alias $foo $bar
+#     ^^^^^^^^^^^^^^^
+class Prism::AliasGlobalVariableNode < ::Prism::Node
+  # Initialize a new AliasGlobalVariableNode node.
+  #
+  # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
+  def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # The location of the `alias` keyword.
+  #
+  #     alias $foo $bar
+  #     ^^^^^
+  def keyword_loc; end
+
+  # Represents the new name of the global variable that can be used after aliasing.
+  #
+  #     alias $foo $bar
+  #           ^^^^
+  def new_name; end
+
+  # Represents the old name of the global variable that can be used before aliasing.
+  #
+  #     alias $foo $bar
+  #                ^^^^
+  def old_name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `alias` keyword to alias a method.
+#
+#     alias foo bar
+#     ^^^^^^^^^^^^^
+class Prism::AliasMethodNode < ::Prism::Node
+  # Initialize a new AliasMethodNode node.
+  #
+  # @return [AliasMethodNode] a new instance of AliasMethodNode
+  def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # attr_reader new_name: SymbolNode | InterpolatedSymbolNode
+  def new_name; end
+
+  # attr_reader old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode
+  def old_name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an alternation pattern in pattern matching.
+#
+#     foo => bar | baz
+#            ^^^^^^^^^
+class Prism::AlternationPatternNode < ::Prism::Node
+  # Initialize a new AlternationPatternNode node.
+  #
+  # @return [AlternationPatternNode] a new instance of AlternationPatternNode
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader left: Prism::node
+  def left; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader right: Prism::node
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&` operator or the `and` keyword.
+#
+#     left and right
+#     ^^^^^^^^^^^^^^
+class Prism::AndNode < ::Prism::Node
+  # Initialize a new AndNode node.
+  #
+  # @return [AndNode] a new instance of AndNode
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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
+  #     ^
+  def left; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `and` keyword or the `&&` operator.
+  #
+  #     left and right
+  #          ^^^
+  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
+  #           ^
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a set of arguments to a method or a keyword.
+#
+#     return foo, bar, baz
+#            ^^^^^^^^^^^^^
+class Prism::ArgumentsNode < ::Prism::Node
+  # Initialize a new ArgumentsNode node.
+  #
+  # @return [ArgumentsNode] a new instance of ArgumentsNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, arguments); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: Array[Prism::node]
+  sig { returns(T::Array[Prism::Node]) }
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def contains_keyword_splat?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def contains_keyword_splat?; end
+
+  # def contains_keywords?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def contains_keywords?; end
+
+  # def contains_splat?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).returns(Prism::ArgumentsNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for arguments nodes.
+module Prism::ArgumentsNodeFlags; end
+
+# if arguments contain keywords
+Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer)
+
+# if arguments contain keyword splat
+Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# if arguments contain splat
+Prism::ArgumentsNodeFlags::CONTAINS_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]
+#     ^^^^^^^^^
+class Prism::ArrayNode < ::Prism::Node
+  # Initialize a new ArrayNode node.
+  #
+  # @return [ArrayNode] a new instance of ArrayNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, elements, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # Represents the optional source location for the closing token.
+  #
+  #     [1,2,3]                 # "]"
+  #     %w[foo bar baz]         # "]"
+  #     %I(apple orange banana) # ")"
+  #     foo = 1, 2, 3           # nil
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def contains_splat?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def contains_splat?; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
+  sig { returns(T::Array[Prism::Node]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # Represents the optional source location for the opening token.
+  #
+  #     [1,2,3]                 # "["
+  #     %w[foo bar baz]         # "%w["
+  #     %I(apple orange banana) # "%I("
+  #     foo = 1, 2, 3           # nil
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for array nodes.
+module Prism::ArrayNodeFlags; end
+
+# if array contains splat nodes
+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]
+#     ^^^^^^^^^^^^^^^^^^^
+class Prism::ArrayPatternNode < ::Prism::Node
+  # Initialize a new ArrayPatternNode node.
+  #
+  # @return [ArrayPatternNode] a new instance of ArrayPatternNode
+  def initialize(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String?
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader constant: Prism::node?
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  def opening_loc; end
+
+  # attr_reader posts: Array[Prism::node]
+  def posts; end
+
+  # attr_reader requireds: Array[Prism::node]
+  def requireds; end
+
+  # attr_reader rest: Prism::node?
+  def rest; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a hash key/value pair.
+#
+#     { a => b }
+#       ^^^^^^
+class Prism::AssocNode < ::Prism::Node
+  # Initialize a new AssocNode node.
+  #
+  # @return [AssocNode] a new instance of AssocNode
+  def initialize(source, node_id, location, flags, key, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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 }
+  #       ^^^^^^^^^^
+  def key; end
+
+  # def operator: () -> String?
+  def operator; end
+
+  # The location of the `=>` operator, if present.
+  #
+  #     { foo => bar }
+  #           ^^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  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 }
+  #          ^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a splat in a hash literal.
+#
+#     { **foo }
+#       ^^^^^
+class Prism::AssocSplatNode < ::Prism::Node
+  # Initialize a new AssocSplatNode node.
+  #
+  # @return [AssocSplatNode] a new instance of AssocSplatNode
+  def initialize(source, node_id, location, flags, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `**` operator.
+  #
+  #     { **x }
+  #       ^^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
+  #
+  #     { **foo }
+  #         ^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# The FFI backend is used on other Ruby implementations.
+Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
+
+# Represents reading a reference to a field in the previous match.
+#
+#     $'
+#     ^^
+class Prism::BackReferenceReadNode < ::Prism::Node
+  # Initialize a new BackReferenceReadNode node.
+  #
+  # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the back-reference variable, including the leading `$`.
+  #
+  #     $& # name `:$&`
+  #
+  #     $+ # name `:$+`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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.
+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.
+  sig { params(node: T.nilable(Prism::Node)).void }
+  def visit(node); end
+
+  # Visits each node in `nodes` by calling `accept` on each one.
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
+  def visit_all(nodes); end
+
+  # Visits the child nodes of `node` by calling `accept` on each one.
+  sig { params(node: Prism::Node).void }
+  def visit_child_nodes(node); end
+end
+
+# Represents a begin statement.
+#
+#     begin
+#       foo
+#     end
+#     ^^^^^
+class Prism::BeginNode < ::Prism::Node
+  # Initialize a new BeginNode node.
+  #
+  # @return [BeginNode] a new instance of BeginNode
+  def initialize(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def begin_keyword: () -> String?
+  def begin_keyword; end
+
+  # attr_reader begin_keyword_loc: Location?
+  def begin_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  def else_clause; end
+
+  # def end_keyword: () -> String?
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  def end_keyword_loc; end
+
+  # attr_reader ensure_clause: EnsureNode?
+  def ensure_clause; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  def newline_flag!(lines); end
+
+  # attr_reader rescue_clause: RescueNode?
+  def rescue_clause; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a block argument using `&`.
+#
+#     bar(&args)
+#     ^^^^^^^^^^
+class Prism::BlockArgumentNode < ::Prism::Node
+  # Initialize a new BlockArgumentNode node.
+  #
+  # @return [BlockArgumentNode] a new instance of BlockArgumentNode
+  def initialize(source, node_id, location, flags, expression, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node?
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a block local variable.
+#
+#     a { |; b| }
+#            ^
+class Prism::BlockLocalVariableNode < ::Prism::Node
+  # Initialize a new BlockLocalVariableNode node.
+  #
+  # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BlockLocalVariableNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a block of ruby code.
+#
+#     [1, 2, 3].each { |i| puts x }
+#                    ^^^^^^^^^^^^^^
+class Prism::BlockNode < ::Prism::Node
+  # Initialize a new BlockNode node.
+  #
+  # @return [BlockNode] a new instance of BlockNode
+  def initialize(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: StatementsNode | BeginNode | nil
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a block parameter of a method, block, or lambda definition.
+#
+#     def a(&b)
+#           ^^
+#     end
+class Prism::BlockParameterNode < ::Prism::Node
+  # Initialize a new BlockParameterNode node.
+  #
+  # @return [BlockParameterNode] a new instance of BlockParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a block's parameters declaration.
+#
+#     -> (a, b = 1; local) { }
+#        ^^^^^^^^^^^^^^^^^
+#
+#     foo do |a, b = 1; local|
+#            ^^^^^^^^^^^^^^^^^
+#     end
+class Prism::BlockParametersNode < ::Prism::Node
+  # Initialize a new BlockParametersNode node.
+  #
+  # @return [BlockParametersNode] a new instance of BlockParametersNode
+  def initialize(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String?
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[BlockLocalVariableNode]
+  def locals; end
+
+  # def opening: () -> String?
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  def opening_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `break` keyword.
+#
+#     break foo
+#     ^^^^^^^^^
+class Prism::BreakNode < ::Prism::Node
+  # Initialize a new BreakNode node.
+  #
+  # @return [BreakNode] a new instance of BreakNode
+  def initialize(source, node_id, location, flags, arguments, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     break foo
+  #           ^^^
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # The location of the `break` keyword.
+  #
+  #     break foo
+  #     ^^^^^
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call.
+#
+#     foo.bar &&= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::CallAndWriteNode < ::Prism::Node
+  # Initialize a new CallAndWriteNode node.
+  #
+  # @return [CallAndWriteNode] a new instance of CallAndWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^^^^^^
+class Prism::CallNode < ::Prism::Node
+  # Initialize a new CallNode node.
+  #
+  # @return [CallNode] a new instance of CallNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(Prism::Node)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: Prism::node?) -> CallNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(Prism::Node)
+    ).returns(Prism::CallNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Prism::node? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # When a call node has the attribute_write flag set, it means that the call
+  # is using the attribute write syntax. This is either a method call to []=
+  # or a method call to a method that ends with =. Either way, the = sign is
+  # present in the source.
+  #
+  # Prism returns the message_loc _without_ the = sign attached, because there
+  # can be any amount of space between the message and the = sign. However,
+  # sometimes you want the location of the full message including the inner
+  # space and the = sign. This method provides that.
+  sig { returns(T.nilable(Prism::Location)) }
+  def full_message_loc; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # def opening: () -> String?
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  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
+  #     ^^^
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for call nodes.
+module Prism::CallNodeFlags; end
+
+# a call that is an attribute write, so the value being written should be returned
+Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
+
+# a call that ignores method visibility
+Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer)
+
+# &. operator
+Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer)
+
+# a call that could have been a local variable
+Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer)
+
+# Represents the use of an assignment operator on a call.
+#
+#     foo.bar += baz
+#     ^^^^^^^^^^^^^^
+class Prism::CallOperatorWriteNode < ::Prism::Node
+  # Initialize a new CallOperatorWriteNode node.
+  #
+  # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader binary_operator: Symbol
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call.
+#
+#     foo.bar ||= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::CallOrWriteNode < ::Prism::Node
+  # Initialize a new CallOrWriteNode node.
+  #
+  # @return [CallOrWriteNode] a new instance of CallOrWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String?
+  sig { returns(T.nilable(String)) }
+  def message; end
+
+  # attr_reader message_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def message_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader read_name: Symbol
+  sig { returns(Symbol) }
+  def read_name; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  # attr_reader write_name: Symbol
+  sig { returns(Symbol) }
+  def write_name; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#         ^^^^^^^
+class Prism::CallTargetNode < ::Prism::Node
+  # Initialize a new CallTargetNode node.
+  #
+  # @return [CallTargetNode] a new instance of CallTargetNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # def call_operator: () -> String
+  sig { returns(String) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location
+  sig { returns(Prism::Location) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).returns(Prism::CallTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def message: () -> String
+  sig { returns(String) }
+  def message; end
+
+  # attr_reader message_loc: Location
+  sig { returns(Prism::Location) }
+  def message_loc; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader receiver: Prism::node
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable in pattern matching.
+#
+#     foo => [bar => baz]
+#            ^^^^^^^^^^^^
+class Prism::CapturePatternNode < ::Prism::Node
+  # Initialize a new CapturePatternNode node.
+  #
+  # @return [CapturePatternNode] a new instance of CapturePatternNode
+  def initialize(source, node_id, location, flags, value, target, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: Prism::node, ?operator_loc: Location) -> CapturePatternNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader target: Prism::node
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of a case statement for pattern matching.
+#
+#     case true
+#     in false
+#     end
+#     ^^^^^^^^^
+class Prism::CaseMatchNode < ::Prism::Node
+  # Initialize a new CaseMatchNode node.
+  #
+  # @return [CaseMatchNode] a new instance of CaseMatchNode
+  def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Prism::node]
+  def conditions; end
+
+  # Returns the else clause of the case match node. This method is deprecated
+  # in favor of #else_clause.
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[Prism::node], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[Prism::node], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  def else_clause; end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader predicate: Prism::node?
+  def predicate; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of a case statement.
+#
+#     case true
+#     when false
+#     end
+#     ^^^^^^^^^^
+class Prism::CaseNode < ::Prism::Node
+  # Initialize a new CaseNode node.
+  #
+  # @return [CaseNode] a new instance of CaseNode
+  def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def case_keyword: () -> String
+  def case_keyword; end
+
+  # attr_reader case_keyword_loc: Location
+  def case_keyword_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Prism::node]
+  def conditions; end
+
+  # Returns the else clause of the case node. This method is deprecated in
+  # favor of #else_clause.
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[Prism::node], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[Prism::node], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # attr_reader else_clause: ElseNode?
+  def else_clause; end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader predicate: Prism::node?
+  def predicate; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a class declaration involving the `class` keyword.
+#
+#     class Foo end
+#     ^^^^^^^^^^^^^
+class Prism::ClassNode < ::Prism::Node
+  # Initialize a new ClassNode node.
+  #
+  # @return [ClassNode] a new instance of ClassNode
+  def initialize(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: Prism::node
+  def constant_path; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: Prism::node, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: Prism::node, inheritance_operator_loc: Location?, superclass: Prism::node?, body: Prism::node?, end_keyword_loc: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inheritance_operator: () -> String?
+  def inheritance_operator; end
+
+  # attr_reader inheritance_operator_loc: Location?
+  def inheritance_operator_loc; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader superclass: Prism::node?
+  def superclass; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a class variable.
+#
+#     @@target &&= value
+#     ^^^^^^^^^^^^^^^^^^
+class Prism::ClassVariableAndWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableAndWriteNode node.
+  #
+  # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to a class variable using an operator that isn't `=`.
+#
+#     @@target += value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableOperatorWriteNode node.
+  #
+  # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a class variable.
+#
+#     @@target ||= value
+#     ^^^^^^^^^^^^^^^^^^
+class Prism::ClassVariableOrWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableOrWriteNode node.
+  #
+  # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents referencing a class variable.
+#
+#     @@foo
+#     ^^^^^
+class Prism::ClassVariableReadNode < ::Prism::Node
+  # Initialize a new ClassVariableReadNode node.
+  #
+  # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a class variable in a context that doesn't have an explicit value.
+#
+#     @@foo, @@bar = baz
+#     ^^^^^  ^^^^^
+class Prism::ClassVariableTargetNode < ::Prism::Node
+  # Initialize a new ClassVariableTargetNode node.
+  #
+  # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a class variable.
+#
+#     @@foo = 1
+#     ^^^^^^^^^
+class Prism::ClassVariableWriteNode < ::Prism::Node
+  # Initialize a new ClassVariableWriteNode node.
+  #
+  # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     @@abc = 123     # name `@@abc`
+  #
+  #     @@_test = :test # name `@@_test`
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     @@foo = :bar
+  #     ^^^^^
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     @@foo = :bar
+  #           ^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     @@foo = :bar
+  #             ^^^^
+  #
+  #     @@_xyz = 123
+  #              ^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents a comment that was encountered during parsing. It is the
+# base class for all comment types.
+class Prism::Comment
+  abstract!
+
+  # Create a new comment object with the given location.
+  #
+  # @return [Comment] a new instance of Comment
+  sig { params(location: Prism::Location).void }
+  def initialize(location); end
+
+  # Implement the hash pattern matching interface for Comment.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The location of this comment in the source.
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Returns the content of the comment by slicing it from the source code.
+  sig { returns(String) }
+  def slice; end
+
+  sig { abstract.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]]]]]]]]
+class Prism::Compiler < ::Prism::Visitor
+  # Visit an individual node.
+  sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) }
+  def visit(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasGlobalVariableNode node
+  def visit_alias_global_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AliasMethodNode node
+  def visit_alias_method_node(node); end
+
+  # Visit a list of nodes.
+  sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) }
+  def visit_all(nodes); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AlternationPatternNode node
+  def visit_alternation_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AndNode node
+  def visit_and_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArgumentsNode node
+  def visit_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayNode node
+  def visit_array_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ArrayPatternNode node
+  def visit_array_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocNode node
+  def visit_assoc_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a AssocSplatNode node
+  def visit_assoc_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BackReferenceReadNode node
+  def visit_back_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BeginNode node
+  def visit_begin_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockArgumentNode node
+  def visit_block_argument_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockLocalVariableNode node
+  def visit_block_local_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockNode node
+  def visit_block_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParameterNode node
+  def visit_block_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BlockParametersNode node
+  def visit_block_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a BreakNode node
+  def visit_break_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallAndWriteNode node
+  def visit_call_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallNode node
+  def visit_call_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOperatorWriteNode node
+  def visit_call_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallOrWriteNode node
+  def visit_call_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CallTargetNode node
+  def visit_call_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CapturePatternNode node
+  def visit_capture_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseMatchNode node
+  def visit_case_match_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a CaseNode node
+  def visit_case_node(node); end
+
+  # Visit the child nodes of the given node.
+  sig { params(node: Prism::Node).returns(T::Array[T.untyped]) }
+  def visit_child_nodes(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassNode node
+  def visit_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableAndWriteNode node
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOperatorWriteNode node
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableOrWriteNode node
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableReadNode node
+  def visit_class_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableTargetNode node
+  def visit_class_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ClassVariableWriteNode node
+  def visit_class_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantAndWriteNode node
+  def visit_constant_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOperatorWriteNode node
+  def visit_constant_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantOrWriteNode node
+  def visit_constant_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathAndWriteNode node
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathNode node
+  def visit_constant_path_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOperatorWriteNode node
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathOrWriteNode node
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathTargetNode node
+  def visit_constant_path_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantPathWriteNode node
+  def visit_constant_path_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantReadNode node
+  def visit_constant_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantTargetNode node
+  def visit_constant_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ConstantWriteNode node
+  def visit_constant_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefNode node
+  def visit_def_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a DefinedNode node
+  def visit_defined_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ElseNode node
+  def visit_else_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedStatementsNode node
+  def visit_embedded_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EmbeddedVariableNode node
+  def visit_embedded_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a EnsureNode node
+  def visit_ensure_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FalseNode node
+  def visit_false_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FindPatternNode node
+  def visit_find_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FlipFlopNode node
+  def visit_flip_flop_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a FloatNode node
+  def visit_float_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForNode node
+  def visit_for_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingArgumentsNode node
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingParameterNode node
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ForwardingSuperNode node
+  def visit_forwarding_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableAndWriteNode node
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOperatorWriteNode node
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableOrWriteNode node
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableReadNode node
+  def visit_global_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableTargetNode node
+  def visit_global_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a GlobalVariableWriteNode node
+  def visit_global_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashNode node
+  def visit_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a HashPatternNode node
+  def visit_hash_pattern_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IfNode node
+  def visit_if_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImaginaryNode node
+  def visit_imaginary_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitNode node
+  def visit_implicit_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ImplicitRestNode node
+  def visit_implicit_rest_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InNode node
+  def visit_in_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexAndWriteNode node
+  def visit_index_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOperatorWriteNode node
+  def visit_index_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexOrWriteNode node
+  def visit_index_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IndexTargetNode node
+  def visit_index_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableAndWriteNode node
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOperatorWriteNode node
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableOrWriteNode node
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableReadNode node
+  def visit_instance_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableTargetNode node
+  def visit_instance_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InstanceVariableWriteNode node
+  def visit_instance_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a IntegerNode node
+  def visit_integer_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedMatchLastLineNode node
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedRegularExpressionNode node
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedStringNode node
+  def visit_interpolated_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedSymbolNode node
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a InterpolatedXStringNode node
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ItLocalVariableReadNode node
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ItParametersNode node
+  def visit_it_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordHashNode node
+  def visit_keyword_hash_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a KeywordRestParameterNode node
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LambdaNode node
+  def visit_lambda_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableAndWriteNode node
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOperatorWriteNode node
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableOrWriteNode node
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableReadNode node
+  def visit_local_variable_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableTargetNode node
+  def visit_local_variable_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a LocalVariableWriteNode node
+  def visit_local_variable_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchLastLineNode node
+  def visit_match_last_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchPredicateNode node
+  def visit_match_predicate_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchRequiredNode node
+  def visit_match_required_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MatchWriteNode node
+  def visit_match_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MissingNode node
+  def visit_missing_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ModuleNode node
+  def visit_module_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiTargetNode node
+  def visit_multi_target_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a MultiWriteNode node
+  def visit_multi_write_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NextNode node
+  def visit_next_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NilNode node
+  def visit_nil_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NoKeywordsParameterNode node
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedParametersNode node
+  def visit_numbered_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a NumberedReferenceReadNode node
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalKeywordParameterNode node
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OptionalParameterNode node
+  def visit_optional_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a OrNode node
+  def visit_or_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParametersNode node
+  def visit_parameters_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ParenthesesNode node
+  def visit_parentheses_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedExpressionNode node
+  def visit_pinned_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PinnedVariableNode node
+  def visit_pinned_variable_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PostExecutionNode node
+  def visit_post_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a PreExecutionNode node
+  def visit_pre_execution_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ProgramNode node
+  def visit_program_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RangeNode node
+  def visit_range_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RationalNode node
+  def visit_rational_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RedoNode node
+  def visit_redo_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RegularExpressionNode node
+  def visit_regular_expression_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredKeywordParameterNode node
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RequiredParameterNode node
+  def visit_required_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueModifierNode node
+  def visit_rescue_modifier_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RescueNode node
+  def visit_rescue_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RestParameterNode node
+  def visit_rest_parameter_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a RetryNode node
+  def visit_retry_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ReturnNode node
+  def visit_return_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SelfNode node
+  def visit_self_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a ShareableConstantNode node
+  def visit_shareable_constant_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SingletonClassNode node
+  def visit_singleton_class_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceEncodingNode node
+  def visit_source_encoding_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceFileNode node
+  def visit_source_file_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SourceLineNode node
+  def visit_source_line_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SplatNode node
+  def visit_splat_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StatementsNode node
+  def visit_statements_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a StringNode node
+  def visit_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SuperNode node
+  def visit_super_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a SymbolNode node
+  def visit_symbol_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a TrueNode node
+  def visit_true_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UndefNode node
+  def visit_undef_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UnlessNode node
+  def visit_unless_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a UntilNode node
+  def visit_until_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhenNode node
+  def visit_when_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a WhileNode node
+  def visit_while_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a XStringNode node
+  def visit_x_string_node(node); end
+
+  # Visit the child nodes of the given node.
+  # Compile a YieldNode node
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant.
+#
+#     Target &&= value
+#     ^^^^^^^^^^^^^^^^
+class Prism::ConstantAndWriteNode < ::Prism::Node
+  # Initialize a new ConstantAndWriteNode node.
+  #
+  # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to a constant using an operator that isn't `=`.
+#
+#     Target += value
+#     ^^^^^^^^^^^^^^^
+class Prism::ConstantOperatorWriteNode < ::Prism::Node
+  # Initialize a new ConstantOperatorWriteNode node.
+  #
+  # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant.
+#
+#     Target ||= value
+#     ^^^^^^^^^^^^^^^^
+class Prism::ConstantOrWriteNode < ::Prism::Node
+  # Initialize a new ConstantOrWriteNode node.
+  #
+  # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant path.
+#
+#     Parent::Child &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+class Prism::ConstantPathAndWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathAndWriteNode node.
+  #
+  # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents accessing a constant through a path of `::` operators.
+#
+#     Foo::Bar
+#     ^^^^^^^^
+class Prism::ConstantPathNode < ::Prism::Node
+  # Initialize a new ConstantPathNode node.
+  #
+  # @return [ConstantPathNode] a new instance of ConstantPathNode
+  def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # Previously, we had a child node on this class that contained either a
+  # constant read or a missing node. To not cause a breaking change, we
+  # continue to supply that API.
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  def delimiter; end
+
+  # The location of the `::` delimiter.
+  #
+  #     ::Foo
+  #     ^^
+  #
+  #     One::Two
+  #        ^^
+  def delimiter_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the constant being accessed. This could be `nil` in the event of a syntax error.
+  def name; end
+
+  # The location of the name of the constant.
+  #
+  #     ::Foo
+  #       ^^^
+  #
+  #     One::Two
+  #          ^^^
+  def name_loc; end
+
+  # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
+  #
+  #     Foo::Bar
+  #     ^^^
+  #
+  #     self::Test
+  #     ^^^^
+  #
+  #     a.b::C
+  #     ^^^
+  def parent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
+
+# An error class raised when missing nodes are found while computing a
+# constant path's full name. For example:
+# Foo:: -> raises because the constant path is missing the last part
+class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError; end
+
+# Represents assigning to a constant path using an operator that isn't `=`.
+#
+#     Parent::Child += value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathOperatorWriteNode node.
+  #
+  # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
+  def initialize(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant path.
+#
+#     Parent::Child ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+class Prism::ConstantPathOrWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathOrWriteNode node.
+  #
+  # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader target: ConstantPathNode
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^^^^^^  ^^^^^^^^
+class Prism::ConstantPathTargetNode < ::Prism::Node
+  # Initialize a new ConstantPathTargetNode node.
+  #
+  # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
+  def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # Previously, we had a child node on this class that contained either a
+  # constant read or a missing node. To not cause a breaking change, we
+  # continue to supply that API.
+  def child; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # def delimiter: () -> String
+  def delimiter; end
+
+  # attr_reader delimiter_loc: Location
+  def delimiter_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant path. For example: "Foo::Bar"
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant path.
+  # For example: [:Foo, :Bar]
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # attr_reader parent: Prism::node?
+  def parent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a constant path.
+#
+#     ::Foo = 1
+#     ^^^^^^^^^
+#
+#     Foo::Bar = 1
+#     ^^^^^^^^^^^^
+#
+#     ::Foo::Bar = 1
+#     ^^^^^^^^^^^^^^
+class Prism::ConstantPathWriteNode < ::Prism::Node
+  # Initialize a new ConstantPathWriteNode node.
+  #
+  # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
+  def initialize(source, node_id, location, flags, target, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     ::ABC = 123
+  #           ^
+  def operator_loc; end
+
+  # A node representing the constant path being written to.
+  #
+  #     Foo::Bar = 1
+  #     ^^^^^^^^
+  #
+  #     ::Foo = :abc
+  #     ^^^^^
+  def target; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     FOO::BAR = :abc
+  #                ^^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents referencing a constant.
+#
+#     Foo
+#     ^^^
+class Prism::ConstantReadNode < ::Prism::Node
+  # Initialize a new ConstantReadNode node.
+  #
+  # @return [ConstantReadNode] a new instance of ConstantReadNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a constant in a context that doesn't have an explicit value.
+#
+#     Foo, Bar = baz
+#     ^^^  ^^^
+class Prism::ConstantTargetNode < ::Prism::Node
+  # Initialize a new ConstantTargetNode node.
+  #
+  # @return [ConstantTargetNode] a new instance of ConstantTargetNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a constant.
+#
+#     Foo = 1
+#     ^^^^^^^
+class Prism::ConstantWriteNode < ::Prism::Node
+  # Initialize a new ConstantWriteNode node.
+  #
+  # @return [ConstantWriteNode] a new instance of ConstantWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns the full name of this constant. For example: "Foo"
+  sig { returns(String) }
+  def full_name; end
+
+  # Returns the list of parts for the full name of this constant.
+  # For example: [:Foo]
+  sig { returns(T::Array[Symbol]) }
+  def full_name_parts; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+  #
+  #     Foo = :bar # name `:Foo`
+  #
+  #     XYZ = 1    # name `:XYZ`
+  def name; end
+
+  # The location of the constant name.
+  #
+  #     FOO = 1
+  #     ^^^
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     FOO = :bar
+  #         ^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     FOO = :bar
+  #           ^^^^
+  #
+  #     MyClass = Class.new
+  #               ^^^^^^^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+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.for("[1]")
+#
+#     Prism::ArrayNode.new(
+#       source,
+#       0,
+#       Prism::Location.new(source, 0, 3),
+#       0,
+#       [
+#         Prism::IntegerNode.new(
+#           source,
+#           0,
+#           Prism::Location.new(source, 1, 1),
+#           Prism::IntegerBaseFlags::DECIMAL,
+#           1
+#         )
+#       ],
+#       Prism::Location.new(source, 0, 1),
+#       Prism::Location.new(source, 2, 1)
+#     )
+#
+# you could instead write:
+#
+#     class Builder
+#       include Prism::DSL
+#
+#       attr_reader :default_source
+#
+#       def initialize
+#         @default_source = source("[1]")
+#       end
+#
+#       def build
+#         array_node(
+#           location: location(start_offset: 0, length: 3),
+#           elements: [
+#             integer_node(
+#               location: location(start_offset: 1, length: 1),
+#               flags: integer_base_flag(:decimal),
+#               value: 1
+#             )
+#           ],
+#           opening_loc: location(start_offset: 0, length: 1),
+#           closing_loc: location(start_offset: 2, length: 1)
+#         )
+#       end
+#     end
+#
+# This is mostly helpful in the context of generating trees programmatically.
+module Prism::DSL
+  extend ::Prism::DSL
+
+  # Create a new AliasGlobalVariableNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode),
+      old_name: T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasGlobalVariableNode)
+  end
+  def alias_global_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new AliasMethodNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      new_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode),
+      old_name: T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::AliasMethodNode)
+  end
+  def alias_method_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new AlternationPatternNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AlternationPatternNode)
+  end
+  def alternation_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new AndNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::AndNode)
+  end
+  def and_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new ArgumentsNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T::Array[Prism::Node]
+    ).returns(Prism::ArgumentsNode)
+  end
+  def arguments_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ArgumentsNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def arguments_node_flag(name); end
+
+  # Create a new ArrayNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayNode)
+  end
+  def array_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ArrayNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def array_node_flag(name); end
+
+  # Create a new ArrayPatternNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(Prism::Node),
+      requireds: T::Array[Prism::Node],
+      rest: T.nilable(Prism::Node),
+      posts: T::Array[Prism::Node],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ArrayPatternNode)
+  end
+  def array_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new AssocNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      key: Prism::Node,
+      value: Prism::Node,
+      operator_loc: T.nilable(Prism::Location)
+    ).returns(Prism::AssocNode)
+  end
+  def assoc_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new AssocSplatNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::AssocSplatNode)
+  end
+  def assoc_splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BackReferenceReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BackReferenceReadNode)
+  end
+  def back_reference_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new BeginNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      begin_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      rescue_clause: T.nilable(Prism::RescueNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      ensure_clause: T.nilable(Prism::EnsureNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BeginNode)
+  end
+  def begin_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new BlockArgumentNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockArgumentNode)
+  end
+  def block_argument_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BlockLocalVariableNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::BlockLocalVariableNode)
+  end
+  def block_local_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new BlockNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      parameters: T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode)),
+      body: T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode)),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::BlockNode)
+  end
+  def block_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new BlockParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::BlockParameterNode)
+  end
+  def block_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new BlockParametersNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parameters: T.nilable(Prism::ParametersNode),
+      locals: T::Array[Prism::BlockLocalVariableNode],
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::BlockParametersNode)
+  end
+  def block_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new BreakNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::BreakNode)
+  end
+  def break_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new CallAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallAndWriteNode)
+  end
+  def call_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      name: Symbol,
+      message_loc: T.nilable(Prism::Location),
+      opening_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: T.nilable(Prism::Location),
+      block: T.nilable(Prism::Node)
+    ).returns(Prism::CallNode)
+  end
+  def call_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the CallNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def call_node_flag(name); end
+
+  # Create a new CallOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOperatorWriteNode)
+  end
+  def call_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      message_loc: T.nilable(Prism::Location),
+      read_name: Symbol,
+      write_name: Symbol,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::CallOrWriteNode)
+  end
+  def call_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new CallTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      call_operator_loc: Prism::Location,
+      name: Symbol,
+      message_loc: Prism::Location
+    ).returns(Prism::CallTargetNode)
+  end
+  def call_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil)); end
+
+  # Create a new CapturePatternNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      target: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::CapturePatternNode)
+  end
+  def capture_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new CaseMatchNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::Node],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseMatchNode)
+  end
+  def case_match_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new CaseNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      predicate: T.nilable(Prism::Node),
+      conditions: T::Array[Prism::Node],
+      else_clause: T.nilable(Prism::ElseNode),
+      case_keyword_loc: Prism::Location,
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::CaseNode)
+  end
+  def case_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ClassNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      constant_path: Prism::Node,
+      inheritance_operator_loc: T.nilable(Prism::Location),
+      superclass: T.nilable(Prism::Node),
+      body: T.nilable(Prism::Node),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ClassNode)
+  end
+  def class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableAndWriteNode)
+  end
+  def class_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ClassVariableOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ClassVariableOperatorWriteNode)
+  end
+  def class_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ClassVariableOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ClassVariableOrWriteNode)
+  end
+  def class_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ClassVariableReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableReadNode)
+  end
+  def class_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ClassVariableTargetNode)
+  end
+  def class_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ClassVariableWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ClassVariableWriteNode)
+  end
+  def class_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantAndWriteNode)
+  end
+  def constant_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantOperatorWriteNode)
+  end
+  def constant_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ConstantOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantOrWriteNode)
+  end
+  def constant_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathAndWriteNode)
+  end
+  def constant_path_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathNode)
+  end
+  def constant_path_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantPathOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::ConstantPathOperatorWriteNode)
+  end
+  def constant_path_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new ConstantPathOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathOrWriteNode)
+  end
+  def constant_path_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantPathTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      parent: T.nilable(Prism::Node),
+      name: T.nilable(Symbol),
+      delimiter_loc: Prism::Location,
+      name_loc: Prism::Location
+    ).returns(Prism::ConstantPathTargetNode)
+  end
+  def constant_path_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new ConstantPathWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      target: Prism::ConstantPathNode,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::ConstantPathWriteNode)
+  end
+  def constant_path_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ConstantReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantReadNode)
+  end
+  def constant_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ConstantTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::ConstantTargetNode)
+  end
+  def constant_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new ConstantWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::ConstantWriteNode)
+  end
+  def constant_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new DefNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      receiver: T.nilable(Prism::Node),
+      parameters: T.nilable(Prism::ParametersNode),
+      body: T.nilable(Prism::Node),
+      locals: T::Array[Symbol],
+      def_keyword_loc: Prism::Location,
+      operator_loc: T.nilable(Prism::Location),
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      equal_loc: T.nilable(Prism::Location),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::DefNode)
+  end
+  def def_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new DefinedNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lparen_loc: T.nilable(Prism::Location),
+      value: Prism::Node,
+      rparen_loc: T.nilable(Prism::Location),
+      keyword_loc: Prism::Location
+    ).returns(Prism::DefinedNode)
+  end
+  def defined_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ElseNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      else_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::ElseNode)
+  end
+  def else_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new EmbeddedStatementsNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      closing_loc: Prism::Location
+    ).returns(Prism::EmbeddedStatementsNode)
+  end
+  def embedded_statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new EmbeddedVariableNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      variable: Prism::Node
+    ).returns(Prism::EmbeddedVariableNode)
+  end
+  def embedded_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the EncodingFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def encoding_flag(name); end
+
+  # Create a new EnsureNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      ensure_keyword_loc: Prism::Location,
+      statements: T.nilable(Prism::StatementsNode),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::EnsureNode)
+  end
+  def ensure_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new FalseNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::FalseNode)
+  end
+  def false_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new FindPatternNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(Prism::Node),
+      left: Prism::Node,
+      requireds: T::Array[Prism::Node],
+      right: Prism::Node,
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::FindPatternNode)
+  end
+  def find_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new FlipFlopNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::FlipFlopNode)
+  end
+  def flip_flop_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new FloatNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Float
+    ).returns(Prism::FloatNode)
+  end
+  def float_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ForNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      index: Prism::Node,
+      collection: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      for_keyword_loc: Prism::Location,
+      in_keyword_loc: Prism::Location,
+      do_keyword_loc: T.nilable(Prism::Location),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::ForNode)
+  end
+  def for_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ForwardingArgumentsNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ForwardingArgumentsNode)
+  end
+  def forwarding_arguments_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ForwardingParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ForwardingParameterNode)
+  end
+  def forwarding_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ForwardingSuperNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      block: T.nilable(Prism::BlockNode)
+    ).returns(Prism::ForwardingSuperNode)
+  end
+  def forwarding_super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableAndWriteNode)
+  end
+  def global_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::GlobalVariableOperatorWriteNode)
+  end
+  def global_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::GlobalVariableOrWriteNode)
+  end
+  def global_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableReadNode)
+  end
+  def global_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::GlobalVariableTargetNode)
+  end
+  def global_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new GlobalVariableWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::GlobalVariableWriteNode)
+  end
+  def global_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new HashNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::HashNode)
+  end
+  def hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new HashPatternNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      constant: T.nilable(Prism::Node),
+      elements: T::Array[Prism::AssocNode],
+      rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
+      opening_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::HashPatternNode)
+  end
+  def hash_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new IfNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      if_keyword_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(T.any(Prism::ElseNode, Prism::IfNode)),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::IfNode)
+  end
+  def if_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new ImaginaryNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)
+    ).returns(Prism::ImaginaryNode)
+  end
+  def imaginary_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end
+
+  # Create a new ImplicitNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node
+    ).returns(Prism::ImplicitNode)
+  end
+  def implicit_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new ImplicitRestNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ImplicitRestNode)
+  end
+  def implicit_rest_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new InNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      pattern: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode),
+      in_loc: Prism::Location,
+      then_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InNode)
+  end
+  def in_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end
+
+  # Create a new IndexAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexAndWriteNode)
+  end
+  def index_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOperatorWriteNode)
+  end
+  def index_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOrWriteNode)
+  end
+  def index_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new IndexTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node)
+    ).returns(Prism::IndexTargetNode)
+  end
+  def index_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableAndWriteNode)
+  end
+  def instance_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      binary_operator: Symbol
+    ).returns(Prism::InstanceVariableOperatorWriteNode)
+  end
+  def instance_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::InstanceVariableOrWriteNode)
+  end
+  def instance_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableReadNode)
+  end
+  def instance_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::InstanceVariableTargetNode)
+  end
+  def instance_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new InstanceVariableWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::InstanceVariableWriteNode)
+  end
+  def instance_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the IntegerBaseFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def integer_base_flag(name); end
+
+  # Create a new IntegerNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).returns(Prism::IntegerNode)
+  end
+  def integer_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new InterpolatedMatchLastLineNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedMatchLastLineNode)
+  end
+  def interpolated_match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedRegularExpressionNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedRegularExpressionNode)
+  end
+  def interpolated_regular_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedStringNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedStringNode)
+  end
+  def interpolated_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the InterpolatedStringNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def interpolated_string_node_flag(name); end
+
+  # Create a new InterpolatedSymbolNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedSymbolNode)
+  end
+  def interpolated_symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new InterpolatedXStringNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedXStringNode)
+  end
+  def interpolated_x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new ItLocalVariableReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ItLocalVariableReadNode)
+  end
+  def it_local_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ItParametersNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::ItParametersNode)
+  end
+  def it_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new KeywordHashNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).returns(Prism::KeywordHashNode)
+  end
+  def keyword_hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the KeywordHashNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def keyword_hash_node_flag(name); end
+
+  # Create a new KeywordRestParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::KeywordRestParameterNode)
+  end
+  def keyword_rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new LambdaNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      operator_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      parameters: T.nilable(Prism::Node),
+      body: T.nilable(Prism::Node)
+    ).returns(Prism::LambdaNode)
+  end
+  def lambda_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # Create a new LocalVariableAndWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableAndWriteNode)
+  end
+  def local_variable_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableOperatorWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      binary_operator: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOperatorWriteNode)
+  end
+  def local_variable_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableOrWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableOrWriteNode)
+  end
+  def local_variable_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableReadNode)
+  end
+  def local_variable_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer
+    ).returns(Prism::LocalVariableTargetNode)
+  end
+  def local_variable_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # Create a new LocalVariableWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      depth: Integer,
+      name_loc: Prism::Location,
+      value: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::LocalVariableWriteNode)
+  end
+  def local_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new Location object.
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
+  def location(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the LoopFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def loop_flag(name); end
+
+  # Create a new MatchLastLineNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::MatchLastLineNode)
+  end
+  def match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new MatchPredicateNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchPredicateNode)
+  end
+  def match_predicate_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new MatchRequiredNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Prism::Node,
+      pattern: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::MatchRequiredNode)
+  end
+  def match_required_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new MatchWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      call: Prism::CallNode,
+      targets: T::Array[Prism::LocalVariableTargetNode]
+    ).returns(Prism::MatchWriteNode)
+  end
+  def match_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), call: T.unsafe(nil), targets: T.unsafe(nil)); end
+
+  # Create a new MissingNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::MissingNode)
+  end
+  def missing_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ModuleNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      module_keyword_loc: Prism::Location,
+      constant_path: Prism::Node,
+      body: T.nilable(Prism::Node),
+      end_keyword_loc: Prism::Location,
+      name: Symbol
+    ).returns(Prism::ModuleNode)
+  end
+  def module_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new MultiTargetNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::MultiTargetNode)
+  end
+  def multi_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # Create a new MultiWriteNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
+      rest: T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode)),
+      rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
+      lparen_loc: T.nilable(Prism::Location),
+      rparen_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::MultiWriteNode)
+  end
+  def multi_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new NextNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      keyword_loc: Prism::Location
+    ).returns(Prism::NextNode)
+  end
+  def next_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new NilNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::NilNode)
+  end
+  def nil_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new NoKeywordsParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      keyword_loc: Prism::Location
+    ).returns(Prism::NoKeywordsParameterNode)
+  end
+  def no_keywords_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new NumberedParametersNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      maximum: Integer
+    ).returns(Prism::NumberedParametersNode)
+  end
+  def numbered_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), maximum: T.unsafe(nil)); end
+
+  # Create a new NumberedReferenceReadNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      number: Integer
+    ).returns(Prism::NumberedReferenceReadNode)
+  end
+  def numbered_reference_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), number: T.unsafe(nil)); end
+
+  # Create a new OptionalKeywordParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalKeywordParameterNode)
+  end
+  def optional_keyword_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new OptionalParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalParameterNode)
+  end
+  def optional_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # Create a new OrNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: Prism::Node,
+      right: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::OrNode)
+  end
+  def or_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ParameterFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def parameter_flag(name); end
+
+  # Create a new ParametersNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
+      optionals: T::Array[Prism::OptionalParameterNode],
+      rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
+      posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
+      keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
+      keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
+      block: T.nilable(Prism::BlockParameterNode)
+    ).returns(Prism::ParametersNode)
+  end
+  def parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Create a new ParenthesesNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T.nilable(Prism::Node),
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::ParenthesesNode)
+  end
+  def parentheses_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new PinnedExpressionNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      operator_loc: Prism::Location,
+      lparen_loc: Prism::Location,
+      rparen_loc: Prism::Location
+    ).returns(Prism::PinnedExpressionNode)
+  end
+  def pinned_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # Create a new PinnedVariableNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      variable: Prism::Node,
+      operator_loc: Prism::Location
+    ).returns(Prism::PinnedVariableNode)
+  end
+  def pinned_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new PostExecutionNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PostExecutionNode)
+  end
+  def post_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new PreExecutionNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      statements: T.nilable(Prism::StatementsNode),
+      keyword_loc: Prism::Location,
+      opening_loc: Prism::Location,
+      closing_loc: Prism::Location
+    ).returns(Prism::PreExecutionNode)
+  end
+  def pre_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # Create a new ProgramNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      statements: Prism::StatementsNode
+    ).returns(Prism::ProgramNode)
+  end
+  def program_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the RangeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def range_flag(name); end
+
+  # Create a new RangeNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::RangeNode)
+  end
+  def range_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new RationalNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).returns(Prism::RationalNode)
+  end
+  def rational_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil)); end
+
+  # Create a new RedoNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::RedoNode)
+  end
+  def redo_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the RegularExpressionFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def regular_expression_flag(name); end
+
+  # Create a new RegularExpressionNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::RegularExpressionNode)
+  end
+  def regular_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new RequiredKeywordParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).returns(Prism::RequiredKeywordParameterNode)
+  end
+  def required_keyword_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # Create a new RequiredParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::RequiredParameterNode)
+  end
+  def required_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # Create a new RescueModifierNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      expression: Prism::Node,
+      keyword_loc: Prism::Location,
+      rescue_expression: Prism::Node
+    ).returns(Prism::RescueModifierNode)
+  end
+  def rescue_modifier_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end
+
+  # Create a new RescueNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      exceptions: T::Array[Prism::Node],
+      operator_loc: T.nilable(Prism::Location),
+      reference: T.nilable(Prism::Node),
+      statements: T.nilable(Prism::StatementsNode),
+      subsequent: T.nilable(Prism::RescueNode)
+    ).returns(Prism::RescueNode)
+  end
+  def rescue_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end
+
+  # Create a new RestParameterNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::RestParameterNode)
+  end
+  def rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # Create a new RetryNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::RetryNode)
+  end
+  def retry_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ReturnNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode)
+    ).returns(Prism::ReturnNode)
+  end
+  def return_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # Create a new SelfNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SelfNode)
+  end
+  def self_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new ShareableConstantNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).returns(Prism::ShareableConstantNode)
+  end
+  def shareable_constant_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the ShareableConstantNodeFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def shareable_constant_node_flag(name); end
+
+  # Create a new SingletonClassNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      locals: T::Array[Symbol],
+      class_keyword_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      expression: Prism::Node,
+      body: T.nilable(Prism::Node),
+      end_keyword_loc: Prism::Location
+    ).returns(Prism::SingletonClassNode)
+  end
+  def singleton_class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new Source object.
+  sig { params(string: String).returns(Prism::Source) }
+  def source(string); end
+
+  # Create a new SourceEncodingNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SourceEncodingNode)
+  end
+  def source_encoding_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new SourceFileNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).returns(Prism::SourceFileNode)
+  end
+  def source_file_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), filepath: T.unsafe(nil)); end
+
+  # Create a new SourceLineNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::SourceLineNode)
+  end
+  def source_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new SplatNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      operator_loc: Prism::Location,
+      expression: T.nilable(Prism::Node)
+    ).returns(Prism::SplatNode)
+  end
+  def splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end
+
+  # Create a new StatementsNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      body: T::Array[Prism::Node]
+    ).returns(Prism::StatementsNode)
+  end
+  def statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the StringFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def string_flag(name); end
+
+  # Create a new StringNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::StringNode)
+  end
+  def string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new SuperNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location),
+      block: T.nilable(Prism::Node)
+    ).returns(Prism::SuperNode)
+  end
+  def super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # Retrieve the value of one of the SymbolFlags flags.
+  sig { params(name: Symbol).returns(Integer) }
+  def symbol_flag(name); end
+
+  # Create a new SymbolNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::SymbolNode)
+  end
+  def symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new TrueNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer
+    ).returns(Prism::TrueNode)
+  end
+  def true_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # Create a new UndefNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
+      keyword_loc: Prism::Location
+    ).returns(Prism::UndefNode)
+  end
+  def undef_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # Create a new UnlessNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      predicate: Prism::Node,
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode),
+      else_clause: T.nilable(Prism::ElseNode),
+      end_keyword_loc: T.nilable(Prism::Location)
+    ).returns(Prism::UnlessNode)
+  end
+  def unless_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # Create a new UntilNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::UntilNode)
+  end
+  def until_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new WhenNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      conditions: T::Array[Prism::Node],
+      then_keyword_loc: T.nilable(Prism::Location),
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhenNode)
+  end
+  def when_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new WhileNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhileNode)
+  end
+  def while_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # Create a new XStringNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::XStringNode)
+  end
+  def x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # Create a new YieldNode node.
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      lparen_loc: T.nilable(Prism::Location),
+      arguments: T.nilable(Prism::ArgumentsNode),
+      rparen_loc: T.nilable(Prism::Location)
+    ).returns(Prism::YieldNode)
+  end
+  def yield_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  private
+
+  # The default location object that gets attached to nodes if no location is
+  # specified, which uses the given source.
+  sig { returns(Prism::Location) }
+  def default_location; end
+
+  # The default node that gets attached to nodes if no node is specified for a
+  # required node field.
+  sig { params(source: Prism::Source, location: Prism::Location).returns(Prism::Node) }
+  def default_node(source, location); end
+
+  # The default source object that gets attached to nodes and locations if no
+  # source is specified.
+  sig { returns(Prism::Source) }
+  def default_source; end
+end
+
+# Represents a method definition.
+#
+#     def method
+#     end
+#     ^^^^^^^^^^
+class Prism::DefNode < ::Prism::Node
+  # Initialize a new DefNode node.
+  #
+  # @return [DefNode] a new instance of DefNode
+  def initialize(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: Prism::node?, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: Prism::node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # def def_keyword: () -> String
+  def def_keyword; end
+
+  # attr_reader def_keyword_loc: Location
+  def def_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  def end_keyword_loc; end
+
+  # def equal: () -> String?
+  def equal; end
+
+  # attr_reader equal_loc: Location?
+  def equal_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  def lparen_loc; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String?
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  def operator_loc; end
+
+  # attr_reader parameters: ParametersNode?
+  def parameters; end
+
+  # attr_reader receiver: Prism::node?
+  def receiver; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `defined?` keyword.
+#
+#     defined?(a)
+#     ^^^^^^^^^^^
+class Prism::DefinedNode < ::Prism::Node
+  # Initialize a new DefinedNode node.
+  #
+  # @return [DefinedNode] a new instance of DefinedNode
+  def initialize(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+class Prism::DesugarAndWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarAndWriteNode] a new instance of DesugarAndWriteNode
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  def arguments; end
+
+  # Desugar `x &&= y` to `x && x = y`
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  def default_source; end
+
+  # Returns the value of attribute node.
+  def node; end
+
+  # Returns the value of attribute read_class.
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  def write_class; 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.
+class Prism::DesugarCompiler < ::Prism::MutationCompiler
+  # @@foo &&= bar
+  #
+  # becomes
+  #
+  # @@foo && @@foo = bar
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  #
+  # becomes
+  #
+  # @@foo = @@foo + bar
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(@@foo) ? @@foo : @@foo = bar
+  def visit_class_variable_or_write_node(node); end
+
+  # Foo &&= bar
+  #
+  # becomes
+  #
+  # Foo && Foo = bar
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  #
+  # becomes
+  #
+  # Foo = Foo + bar
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  #
+  # becomes
+  #
+  # defined?(Foo) ? Foo : Foo = bar
+  def visit_constant_or_write_node(node); end
+
+  # $foo &&= bar
+  #
+  # becomes
+  #
+  # $foo && $foo = bar
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  #
+  # becomes
+  #
+  # $foo = $foo + bar
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  #
+  # becomes
+  #
+  # defined?($foo) ? $foo : $foo = bar
+  def visit_global_variable_or_write_node(node); end
+
+  # becomes
+  def visit_instance_variable_and_write_node(node); end
+
+  # becomes
+  def visit_instance_variable_operator_write_node(node); end
+
+  # becomes
+  def visit_instance_variable_or_write_node(node); end
+
+  # foo &&= bar
+  #
+  # becomes
+  #
+  # foo && foo = bar
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  #
+  # becomes
+  #
+  # foo = foo + bar
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  #
+  # becomes
+  #
+  # foo || foo = bar
+  def visit_local_variable_or_write_node(node); end
+end
+
+class Prism::DesugarOperatorWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarOperatorWriteNode] a new instance of DesugarOperatorWriteNode
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  def arguments; end
+
+  # Desugar `x += y` to `x = x + y`
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  def default_source; end
+
+  # Returns the value of attribute node.
+  def node; end
+
+  # Returns the value of attribute read_class.
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  def write_class; end
+end
+
+class Prism::DesugarOrWriteDefinedNode
+  include ::Prism::DSL
+
+  # @return [DesugarOrWriteDefinedNode] a new instance of DesugarOrWriteDefinedNode
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  def arguments; end
+
+  # Desugar `x ||= y` to `defined?(x) ? x : x = y`
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  def default_source; end
+
+  # Returns the value of attribute node.
+  def node; end
+
+  # Returns the value of attribute read_class.
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  def write_class; end
+end
+
+class Prism::DesugarOrWriteNode
+  include ::Prism::DSL
+
+  # @return [DesugarOrWriteNode] a new instance of DesugarOrWriteNode
+  def initialize(node, default_source, read_class, write_class, **arguments); end
+
+  # Returns the value of attribute arguments.
+  def arguments; end
+
+  # Desugar `x ||= y` to `x || x = y`
+  def compile; end
+
+  # Returns the value of attribute default_source.
+  def default_source; end
+
+  # Returns the value of attribute node.
+  def node; end
+
+  # Returns the value of attribute read_class.
+  def read_class; end
+
+  # Returns the value of attribute write_class.
+  def write_class; 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
+#
+#     listener = OctalListener.new
+#     dispatcher = Prism::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)
+class Prism::Dispatcher < ::Prism::Visitor
+  # Initialize a new dispatcher.
+  #
+  # @return [Dispatcher] a new instance of Dispatcher
+  def initialize; end
+
+  # Walks `root` dispatching events to all registered listeners.
+  #
+  # def dispatch: (Node) -> void
+  def dispatch(node); end
+
+  # Dispatches a single event for `node` to all registered listeners.
+  #
+  # def dispatch_once: (Node) -> void
+  def dispatch_once(node); end
+
+  # attr_reader listeners: Hash[Symbol, Array[Listener]]
+  def listeners; end
+
+  # Register a listener for one or more events.
+  #
+  # def register: (Listener, *Symbol) -> void
+  def register(listener, *events); end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
+  # walking the tree.
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes and continue
+  # walking the tree.
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes and continue
+  # walking the tree.
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes and continue
+  # walking the tree.
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes and continue
+  # walking the tree.
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes and continue
+  # walking the tree.
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes and continue
+  # walking the tree.
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes and continue
+  # walking the tree.
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes and continue
+  # walking the tree.
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes and continue
+  # walking the tree.
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes and continue
+  # walking the tree.
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes and continue
+  # walking the tree.
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
+  # walking the tree.
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes and continue
+  # walking the tree.
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes and continue
+  # walking the tree.
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes and continue
+  # walking the tree.
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes and continue
+  # walking the tree.
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes and continue
+  # walking the tree.
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes and continue
+  # walking the tree.
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes and continue
+  # walking the tree.
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes and continue
+  # walking the tree.
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes and continue
+  # walking the tree.
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes and continue
+  # walking the tree.
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
+  # walking the tree.
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes and continue
+  # walking the tree.
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes and continue
+  # walking the tree.
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes and continue
+  # walking the tree.
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes and continue
+  # walking the tree.
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes and continue
+  # walking the tree.
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes and continue
+  # walking the tree.
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
+  # walking the tree.
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
+  # walking the tree.
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes and continue
+  # walking the tree.
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes and continue
+  # walking the tree.
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes and continue
+  # walking the tree.
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes and continue
+  # walking the tree.
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes and continue
+  # walking the tree.
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes and continue
+  # walking the tree.
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
+  # walking the tree.
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes and continue
+  # walking the tree.
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes and continue
+  # walking the tree.
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
+  # walking the tree.
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes and continue
+  # walking the tree.
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes and continue
+  # walking the tree.
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes and continue
+  # walking the tree.
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes and continue
+  # walking the tree.
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes and continue
+  # walking the tree.
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes and continue
+  # walking the tree.
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes and continue
+  # walking the tree.
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes and continue
+  # walking the tree.
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
+  # walking the tree.
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes and continue
+  # walking the tree.
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
+  # walking the tree.
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
+  # walking the tree.
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes and continue
+  # walking the tree.
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
+  # walking the tree.
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
+  # walking the tree.
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for ItLocalVariableReadNode nodes and continue
+  # walking the tree.
+  def visit_it_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ItParametersNode nodes and continue
+  # walking the tree.
+  def visit_it_parameters_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes and continue
+  # walking the tree.
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
+  # walking the tree.
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes and continue
+  # walking the tree.
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
+  # walking the tree.
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes and continue
+  # walking the tree.
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes and continue
+  # walking the tree.
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes and continue
+  # walking the tree.
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes and continue
+  # walking the tree.
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes and continue
+  # walking the tree.
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes and continue
+  # walking the tree.
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes and continue
+  # walking the tree.
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes and continue
+  # walking the tree.
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes and continue
+  # walking the tree.
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes and continue
+  # walking the tree.
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
+  # walking the tree.
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes and continue
+  # walking the tree.
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
+  # walking the tree.
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
+  # walking the tree.
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes and continue
+  # walking the tree.
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes and continue
+  # walking the tree.
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes and continue
+  # walking the tree.
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes and continue
+  # walking the tree.
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes and continue
+  # walking the tree.
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes and continue
+  # walking the tree.
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes and continue
+  # walking the tree.
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes and continue
+  # walking the tree.
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes and continue
+  # walking the tree.
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes and continue
+  # walking the tree.
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes and continue
+  # walking the tree.
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes and continue
+  # walking the tree.
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes and continue
+  # walking the tree.
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
+  # walking the tree.
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes and continue
+  # walking the tree.
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes and continue
+  # walking the tree.
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes and continue
+  # walking the tree.
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes and continue
+  # walking the tree.
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes and continue
+  # walking the tree.
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes and continue
+  # walking the tree.
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes and continue
+  # walking the tree.
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for ShareableConstantNode nodes and continue
+  # walking the tree.
+  def visit_shareable_constant_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes and continue
+  # walking the tree.
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes and continue
+  # walking the tree.
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes and continue
+  # walking the tree.
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes and continue
+  # walking the tree.
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes and continue
+  # walking the tree.
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes and continue
+  # walking the tree.
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes and continue
+  # walking the tree.
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes and continue
+  # walking the tree.
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes and continue
+  # walking the tree.
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes and continue
+  # walking the tree.
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes and continue
+  # walking the tree.
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes and continue
+  # walking the tree.
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes and continue
+  # walking the tree.
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes and continue
+  # walking the tree.
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes and continue
+  # walking the tree.
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes and continue
+  # walking the tree.
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes and continue
+  # walking the tree.
+  def visit_yield_node(node); end
+end
+
+class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
+  # @return [DispatchOnce] a new instance of DispatchOnce
+  def initialize(listeners); end
+
+  # Returns the value of attribute listeners.
+  def listeners; end
+
+  # Dispatch enter and leave events for AliasGlobalVariableNode nodes.
+  def visit_alias_global_variable_node(node); end
+
+  # Dispatch enter and leave events for AliasMethodNode nodes.
+  def visit_alias_method_node(node); end
+
+  # Dispatch enter and leave events for AlternationPatternNode nodes.
+  def visit_alternation_pattern_node(node); end
+
+  # Dispatch enter and leave events for AndNode nodes.
+  def visit_and_node(node); end
+
+  # Dispatch enter and leave events for ArgumentsNode nodes.
+  def visit_arguments_node(node); end
+
+  # Dispatch enter and leave events for ArrayNode nodes.
+  def visit_array_node(node); end
+
+  # Dispatch enter and leave events for ArrayPatternNode nodes.
+  def visit_array_pattern_node(node); end
+
+  # Dispatch enter and leave events for AssocNode nodes.
+  def visit_assoc_node(node); end
+
+  # Dispatch enter and leave events for AssocSplatNode nodes.
+  def visit_assoc_splat_node(node); end
+
+  # Dispatch enter and leave events for BackReferenceReadNode nodes.
+  def visit_back_reference_read_node(node); end
+
+  # Dispatch enter and leave events for BeginNode nodes.
+  def visit_begin_node(node); end
+
+  # Dispatch enter and leave events for BlockArgumentNode nodes.
+  def visit_block_argument_node(node); end
+
+  # Dispatch enter and leave events for BlockLocalVariableNode nodes.
+  def visit_block_local_variable_node(node); end
+
+  # Dispatch enter and leave events for BlockNode nodes.
+  def visit_block_node(node); end
+
+  # Dispatch enter and leave events for BlockParameterNode nodes.
+  def visit_block_parameter_node(node); end
+
+  # Dispatch enter and leave events for BlockParametersNode nodes.
+  def visit_block_parameters_node(node); end
+
+  # Dispatch enter and leave events for BreakNode nodes.
+  def visit_break_node(node); end
+
+  # Dispatch enter and leave events for CallAndWriteNode nodes.
+  def visit_call_and_write_node(node); end
+
+  # Dispatch enter and leave events for CallNode nodes.
+  def visit_call_node(node); end
+
+  # Dispatch enter and leave events for CallOperatorWriteNode nodes.
+  def visit_call_operator_write_node(node); end
+
+  # Dispatch enter and leave events for CallOrWriteNode nodes.
+  def visit_call_or_write_node(node); end
+
+  # Dispatch enter and leave events for CallTargetNode nodes.
+  def visit_call_target_node(node); end
+
+  # Dispatch enter and leave events for CapturePatternNode nodes.
+  def visit_capture_pattern_node(node); end
+
+  # Dispatch enter and leave events for CaseMatchNode nodes.
+  def visit_case_match_node(node); end
+
+  # Dispatch enter and leave events for CaseNode nodes.
+  def visit_case_node(node); end
+
+  # Dispatch enter and leave events for ClassNode nodes.
+  def visit_class_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
+  def visit_class_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
+  def visit_class_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
+  def visit_class_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableReadNode nodes.
+  def visit_class_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableTargetNode nodes.
+  def visit_class_variable_target_node(node); end
+
+  # Dispatch enter and leave events for ClassVariableWriteNode nodes.
+  def visit_class_variable_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantAndWriteNode nodes.
+  def visit_constant_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
+  def visit_constant_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantOrWriteNode nodes.
+  def visit_constant_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
+  def visit_constant_path_and_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathNode nodes.
+  def visit_constant_path_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
+  def visit_constant_path_operator_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
+  def visit_constant_path_or_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathTargetNode nodes.
+  def visit_constant_path_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantPathWriteNode nodes.
+  def visit_constant_path_write_node(node); end
+
+  # Dispatch enter and leave events for ConstantReadNode nodes.
+  def visit_constant_read_node(node); end
+
+  # Dispatch enter and leave events for ConstantTargetNode nodes.
+  def visit_constant_target_node(node); end
+
+  # Dispatch enter and leave events for ConstantWriteNode nodes.
+  def visit_constant_write_node(node); end
+
+  # Dispatch enter and leave events for DefNode nodes.
+  def visit_def_node(node); end
+
+  # Dispatch enter and leave events for DefinedNode nodes.
+  def visit_defined_node(node); end
+
+  # Dispatch enter and leave events for ElseNode nodes.
+  def visit_else_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedStatementsNode nodes.
+  def visit_embedded_statements_node(node); end
+
+  # Dispatch enter and leave events for EmbeddedVariableNode nodes.
+  def visit_embedded_variable_node(node); end
+
+  # Dispatch enter and leave events for EnsureNode nodes.
+  def visit_ensure_node(node); end
+
+  # Dispatch enter and leave events for FalseNode nodes.
+  def visit_false_node(node); end
+
+  # Dispatch enter and leave events for FindPatternNode nodes.
+  def visit_find_pattern_node(node); end
+
+  # Dispatch enter and leave events for FlipFlopNode nodes.
+  def visit_flip_flop_node(node); end
+
+  # Dispatch enter and leave events for FloatNode nodes.
+  def visit_float_node(node); end
+
+  # Dispatch enter and leave events for ForNode nodes.
+  def visit_for_node(node); end
+
+  # Dispatch enter and leave events for ForwardingArgumentsNode nodes.
+  def visit_forwarding_arguments_node(node); end
+
+  # Dispatch enter and leave events for ForwardingParameterNode nodes.
+  def visit_forwarding_parameter_node(node); end
+
+  # Dispatch enter and leave events for ForwardingSuperNode nodes.
+  def visit_forwarding_super_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
+  def visit_global_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
+  def visit_global_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
+  def visit_global_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableReadNode nodes.
+  def visit_global_variable_read_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableTargetNode nodes.
+  def visit_global_variable_target_node(node); end
+
+  # Dispatch enter and leave events for GlobalVariableWriteNode nodes.
+  def visit_global_variable_write_node(node); end
+
+  # Dispatch enter and leave events for HashNode nodes.
+  def visit_hash_node(node); end
+
+  # Dispatch enter and leave events for HashPatternNode nodes.
+  def visit_hash_pattern_node(node); end
+
+  # Dispatch enter and leave events for IfNode nodes.
+  def visit_if_node(node); end
+
+  # Dispatch enter and leave events for ImaginaryNode nodes.
+  def visit_imaginary_node(node); end
+
+  # Dispatch enter and leave events for ImplicitNode nodes.
+  def visit_implicit_node(node); end
+
+  # Dispatch enter and leave events for ImplicitRestNode nodes.
+  def visit_implicit_rest_node(node); end
+
+  # Dispatch enter and leave events for InNode nodes.
+  def visit_in_node(node); end
+
+  # Dispatch enter and leave events for IndexAndWriteNode nodes.
+  def visit_index_and_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
+  def visit_index_operator_write_node(node); end
+
+  # Dispatch enter and leave events for IndexOrWriteNode nodes.
+  def visit_index_or_write_node(node); end
+
+  # Dispatch enter and leave events for IndexTargetNode nodes.
+  def visit_index_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
+  def visit_instance_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
+  def visit_instance_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableReadNode nodes.
+  def visit_instance_variable_read_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableTargetNode nodes.
+  def visit_instance_variable_target_node(node); end
+
+  # Dispatch enter and leave events for InstanceVariableWriteNode nodes.
+  def visit_instance_variable_write_node(node); end
+
+  # Dispatch enter and leave events for IntegerNode nodes.
+  def visit_integer_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedStringNode nodes.
+  def visit_interpolated_string_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedSymbolNode nodes.
+  def visit_interpolated_symbol_node(node); end
+
+  # Dispatch enter and leave events for InterpolatedXStringNode nodes.
+  def visit_interpolated_x_string_node(node); end
+
+  # Dispatch enter and leave events for ItLocalVariableReadNode nodes.
+  def visit_it_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for ItParametersNode nodes.
+  def visit_it_parameters_node(node); end
+
+  # Dispatch enter and leave events for KeywordHashNode nodes.
+  def visit_keyword_hash_node(node); end
+
+  # Dispatch enter and leave events for KeywordRestParameterNode nodes.
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for LambdaNode nodes.
+  def visit_lambda_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
+  def visit_local_variable_and_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
+  def visit_local_variable_operator_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
+  def visit_local_variable_or_write_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableReadNode nodes.
+  def visit_local_variable_read_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableTargetNode nodes.
+  def visit_local_variable_target_node(node); end
+
+  # Dispatch enter and leave events for LocalVariableWriteNode nodes.
+  def visit_local_variable_write_node(node); end
+
+  # Dispatch enter and leave events for MatchLastLineNode nodes.
+  def visit_match_last_line_node(node); end
+
+  # Dispatch enter and leave events for MatchPredicateNode nodes.
+  def visit_match_predicate_node(node); end
+
+  # Dispatch enter and leave events for MatchRequiredNode nodes.
+  def visit_match_required_node(node); end
+
+  # Dispatch enter and leave events for MatchWriteNode nodes.
+  def visit_match_write_node(node); end
+
+  # Dispatch enter and leave events for MissingNode nodes.
+  def visit_missing_node(node); end
+
+  # Dispatch enter and leave events for ModuleNode nodes.
+  def visit_module_node(node); end
+
+  # Dispatch enter and leave events for MultiTargetNode nodes.
+  def visit_multi_target_node(node); end
+
+  # Dispatch enter and leave events for MultiWriteNode nodes.
+  def visit_multi_write_node(node); end
+
+  # Dispatch enter and leave events for NextNode nodes.
+  def visit_next_node(node); end
+
+  # Dispatch enter and leave events for NilNode nodes.
+  def visit_nil_node(node); end
+
+  # Dispatch enter and leave events for NoKeywordsParameterNode nodes.
+  def visit_no_keywords_parameter_node(node); end
+
+  # Dispatch enter and leave events for NumberedParametersNode nodes.
+  def visit_numbered_parameters_node(node); end
+
+  # Dispatch enter and leave events for NumberedReferenceReadNode nodes.
+  def visit_numbered_reference_read_node(node); end
+
+  # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for OptionalParameterNode nodes.
+  def visit_optional_parameter_node(node); end
+
+  # Dispatch enter and leave events for OrNode nodes.
+  def visit_or_node(node); end
+
+  # Dispatch enter and leave events for ParametersNode nodes.
+  def visit_parameters_node(node); end
+
+  # Dispatch enter and leave events for ParenthesesNode nodes.
+  def visit_parentheses_node(node); end
+
+  # Dispatch enter and leave events for PinnedExpressionNode nodes.
+  def visit_pinned_expression_node(node); end
+
+  # Dispatch enter and leave events for PinnedVariableNode nodes.
+  def visit_pinned_variable_node(node); end
+
+  # Dispatch enter and leave events for PostExecutionNode nodes.
+  def visit_post_execution_node(node); end
+
+  # Dispatch enter and leave events for PreExecutionNode nodes.
+  def visit_pre_execution_node(node); end
+
+  # Dispatch enter and leave events for ProgramNode nodes.
+  def visit_program_node(node); end
+
+  # Dispatch enter and leave events for RangeNode nodes.
+  def visit_range_node(node); end
+
+  # Dispatch enter and leave events for RationalNode nodes.
+  def visit_rational_node(node); end
+
+  # Dispatch enter and leave events for RedoNode nodes.
+  def visit_redo_node(node); end
+
+  # Dispatch enter and leave events for RegularExpressionNode nodes.
+  def visit_regular_expression_node(node); end
+
+  # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
+  def visit_required_keyword_parameter_node(node); end
+
+  # Dispatch enter and leave events for RequiredParameterNode nodes.
+  def visit_required_parameter_node(node); end
+
+  # Dispatch enter and leave events for RescueModifierNode nodes.
+  def visit_rescue_modifier_node(node); end
+
+  # Dispatch enter and leave events for RescueNode nodes.
+  def visit_rescue_node(node); end
+
+  # Dispatch enter and leave events for RestParameterNode nodes.
+  def visit_rest_parameter_node(node); end
+
+  # Dispatch enter and leave events for RetryNode nodes.
+  def visit_retry_node(node); end
+
+  # Dispatch enter and leave events for ReturnNode nodes.
+  def visit_return_node(node); end
+
+  # Dispatch enter and leave events for SelfNode nodes.
+  def visit_self_node(node); end
+
+  # Dispatch enter and leave events for ShareableConstantNode nodes.
+  def visit_shareable_constant_node(node); end
+
+  # Dispatch enter and leave events for SingletonClassNode nodes.
+  def visit_singleton_class_node(node); end
+
+  # Dispatch enter and leave events for SourceEncodingNode nodes.
+  def visit_source_encoding_node(node); end
+
+  # Dispatch enter and leave events for SourceFileNode nodes.
+  def visit_source_file_node(node); end
+
+  # Dispatch enter and leave events for SourceLineNode nodes.
+  def visit_source_line_node(node); end
+
+  # Dispatch enter and leave events for SplatNode nodes.
+  def visit_splat_node(node); end
+
+  # Dispatch enter and leave events for StatementsNode nodes.
+  def visit_statements_node(node); end
+
+  # Dispatch enter and leave events for StringNode nodes.
+  def visit_string_node(node); end
+
+  # Dispatch enter and leave events for SuperNode nodes.
+  def visit_super_node(node); end
+
+  # Dispatch enter and leave events for SymbolNode nodes.
+  def visit_symbol_node(node); end
+
+  # Dispatch enter and leave events for TrueNode nodes.
+  def visit_true_node(node); end
+
+  # Dispatch enter and leave events for UndefNode nodes.
+  def visit_undef_node(node); end
+
+  # Dispatch enter and leave events for UnlessNode nodes.
+  def visit_unless_node(node); end
+
+  # Dispatch enter and leave events for UntilNode nodes.
+  def visit_until_node(node); end
+
+  # Dispatch enter and leave events for WhenNode nodes.
+  def visit_when_node(node); end
+
+  # Dispatch enter and leave events for WhileNode nodes.
+  def visit_while_node(node); end
+
+  # Dispatch enter and leave events for XStringNode nodes.
+  def visit_x_string_node(node); end
+
+  # Dispatch enter and leave events for YieldNode nodes.
+  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.
+class Prism::DotVisitor < ::Prism::Visitor
+  # Initialize a new dot visitor.
+  #
+  # @return [DotVisitor] a new instance of DotVisitor
+  def initialize; end
+
+  # The digraph that is being built.
+  def digraph; end
+
+  # Convert this visitor into a graphviz dot graph string.
+  def to_dot; end
+
+  # Visit a AliasGlobalVariableNode node.
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node.
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node.
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node.
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node.
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node.
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node.
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node.
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node.
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node.
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node.
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node.
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node.
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node.
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node.
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node.
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node.
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node.
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node.
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node.
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node.
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node.
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node.
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node.
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node.
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node.
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node.
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node.
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node.
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node.
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node.
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node.
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node.
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node.
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node.
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node.
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node.
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node.
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node.
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node.
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node.
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node.
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node.
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node.
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node.
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node.
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node.
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node.
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node.
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node.
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node.
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node.
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node.
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node.
+  def visit_float_node(node); end
+
+  # Visit a ForNode node.
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node.
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node.
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node.
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node.
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node.
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node.
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node.
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node.
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node.
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node.
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node.
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node.
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node.
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node.
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node.
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node.
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node.
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node.
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node.
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node.
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node.
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node.
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node.
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node.
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node.
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node.
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node.
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node.
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node.
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node.
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node.
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node.
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a ItLocalVariableReadNode node.
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit a ItParametersNode node.
+  def visit_it_parameters_node(node); end
+
+  # Visit a KeywordHashNode node.
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node.
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node.
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node.
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node.
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node.
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node.
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node.
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node.
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node.
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node.
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node.
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node.
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node.
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node.
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node.
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node.
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node.
+  def visit_next_node(node); end
+
+  # Visit a NilNode node.
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node.
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node.
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node.
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node.
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node.
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node.
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node.
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node.
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node.
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node.
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node.
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node.
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node.
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node.
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node.
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node.
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node.
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node.
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node.
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node.
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node.
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node.
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node.
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node.
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node.
+  def visit_self_node(node); end
+
+  # Visit a ShareableConstantNode node.
+  def visit_shareable_constant_node(node); end
+
+  # Visit a SingletonClassNode node.
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node.
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node.
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node.
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node.
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node.
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node.
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node.
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node.
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node.
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node.
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node.
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node.
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node.
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node.
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node.
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node.
+  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.
+  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.
+  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.
+  def call_node_flags_inspect(node); end
+
+  # Inspect a node that has encoding_flags flags to display the flags as a
+  # comma-separated list.
+  def encoding_flags_inspect(node); end
+
+  # Inspect a node that has integer_base_flags flags to display the flags as a
+  # comma-separated list.
+  def integer_base_flags_inspect(node); end
+
+  # Inspect a node that has interpolated_string_node_flags flags to display the flags as a
+  # comma-separated list.
+  def interpolated_string_node_flags_inspect(node); end
+
+  # Inspect a node that has keyword_hash_node_flags flags to display the flags as a
+  # comma-separated list.
+  def keyword_hash_node_flags_inspect(node); end
+
+  # Inspect a location to display the start and end line and column numbers.
+  def location_inspect(location); end
+
+  # Inspect a node that has loop_flags flags to display the flags as a
+  # comma-separated list.
+  def loop_flags_inspect(node); end
+
+  # Generate a unique node ID for a node throughout the digraph.
+  def node_id(node); end
+
+  # Inspect a node that has parameter_flags flags to display the flags as a
+  # comma-separated list.
+  def parameter_flags_inspect(node); end
+
+  # Inspect a node that has range_flags flags to display the flags as a
+  # comma-separated list.
+  def range_flags_inspect(node); end
+
+  # Inspect a node that has regular_expression_flags flags to display the flags as a
+  # comma-separated list.
+  def regular_expression_flags_inspect(node); end
+
+  # Inspect a node that has shareable_constant_node_flags flags to display the flags as a
+  # comma-separated list.
+  def shareable_constant_node_flags_inspect(node); end
+
+  # Inspect a node that has string_flags flags to display the flags as a
+  # comma-separated list.
+  def string_flags_inspect(node); end
+
+  # Inspect a node that has symbol_flags flags to display the flags as a
+  # comma-separated list.
+  def symbol_flags_inspect(node); end
+end
+
+class Prism::DotVisitor::Digraph
+  # @return [Digraph] a new instance of Digraph
+  def initialize; end
+
+  def edge(value); end
+
+  # Returns the value of attribute edges.
+  def edges; end
+
+  def node(value); end
+
+  # Returns the value of attribute nodes.
+  def nodes; end
+
+  def to_dot; end
+  def waypoint(value); end
+
+  # Returns the value of attribute waypoints.
+  def waypoints; end
+end
+
+class Prism::DotVisitor::Field
+  # @return [Field] a new instance of Field
+  def initialize(name, value, port); end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  # Returns the value of attribute port.
+  def port; end
+
+  def to_dot; end
+
+  # Returns the value of attribute value.
+  def value; end
+end
+
+class Prism::DotVisitor::Table
+  # @return [Table] a new instance of Table
+  def initialize(name); end
+
+  def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
+
+  # Returns the value of attribute fields.
+  def fields; end
+
+  # Returns the value of attribute name.
+  def name; end
+
+  def to_dot; end
+end
+
+# Represents an `else` clause in a `case`, `if`, or `unless` statement.
+#
+#     if a then b else c end
+#                 ^^^^^^^^^^
+class Prism::ElseNode < ::Prism::Node
+  # Initialize a new ElseNode node.
+  #
+  # @return [ElseNode] a new instance of ElseNode
+  def initialize(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # def else_keyword: () -> String
+  def else_keyword; end
+
+  # attr_reader else_keyword_loc: Location
+  def else_keyword_loc; end
+
+  # def end_keyword: () -> String?
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location?
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# EmbDocComment objects correspond to comments that are surrounded by =begin
+# and =end.
+class Prism::EmbDocComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  sig { returns(String) }
+  def inspect; end
+
+  # This can only be true for inline comments.
+  #
+  # @return [Boolean]
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# Represents an interpolated set of statements.
+#
+#     "foo #{bar}"
+#          ^^^^^^
+class Prism::EmbeddedStatementsNode < ::Prism::Node
+  # Initialize a new EmbeddedStatementsNode node.
+  #
+  # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode
+  def initialize(source, node_id, location, flags, opening_loc, statements, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an interpolated variable.
+#
+#     "foo #@bar"
+#          ^^^^^
+class Prism::EmbeddedVariableNode < ::Prism::Node
+  # Initialize a new EmbeddedVariableNode node.
+  #
+  # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
+  def initialize(source, node_id, location, flags, operator_loc, variable); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: Prism::node) -> EmbeddedVariableNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader variable: Prism::node
+  def variable; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for nodes that have unescaped content.
+module Prism::EncodingFlags; end
+
+# internal bytes forced the encoding to binary
+Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# Represents an `ensure` clause in a `begin` statement.
+#
+#     begin
+#       foo
+#     ensure
+#     ^^^^^^
+#       bar
+#     end
+class Prism::EnsureNode < ::Prism::Node
+  # Initialize a new EnsureNode node.
+  #
+  # @return [EnsureNode] a new instance of EnsureNode
+  def initialize(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  # def ensure_keyword: () -> String
+  def ensure_keyword; end
+
+  # attr_reader ensure_keyword_loc: Location
+  def ensure_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the literal `false` keyword.
+#
+#     false
+#     ^^^^^
+class Prism::FalseNode < ::Prism::Node
+  # Initialize a new FalseNode node.
+  #
+  # @return [FalseNode] a new instance of FalseNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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)
+#            ^^^^^^^^^^^^^^^^^^^^
+class Prism::FindPatternNode < ::Prism::Node
+  # Initialize a new FindPatternNode node.
+  #
+  # @return [FindPatternNode] a new instance of FindPatternNode
+  def initialize(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String?
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader constant: Prism::node?
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?left: Prism::node, ?requireds: Array[Prism::node], ?right: Prism::node, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, left: Prism::node, requireds: Array[Prism::node], right: Prism::node, opening_loc: Location?, closing_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader left: Prism::node
+  def left; end
+
+  # def opening: () -> String?
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  def opening_loc; end
+
+  # attr_reader requireds: Array[Prism::node]
+  def requireds; end
+
+  # attr_reader right: Prism::node
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `..` or `...` operators to create flip flops.
+#
+#     baz if foo .. bar
+#            ^^^^^^^^^^
+class Prism::FlipFlopNode < ::Prism::Node
+  # Initialize a new FlipFlopNode node.
+  #
+  # @return [FlipFlopNode] a new instance of FlipFlopNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::FlipFlopNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader left: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader right: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a floating point number literal.
+#
+#     1.0
+#     ^^^
+class Prism::FloatNode < ::Prism::Node
+  # Initialize a new FloatNode node.
+  #
+  # @return [FloatNode] a new instance of FloatNode
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value of the floating point number as a Float.
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `for` keyword.
+#
+#     for i in a end
+#     ^^^^^^^^^^^^^^
+class Prism::ForNode < ::Prism::Node
+  # Initialize a new ForNode node.
+  #
+  # @return [ForNode] a new instance of ForNode
+  def initialize(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # The collection to iterate over.
+  #
+  #     for i in a end
+  #              ^
+  def collection; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: Prism::node, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: Prism::node, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # def do_keyword: () -> String?
+  def do_keyword; end
+
+  # The location of the `do` keyword, if present.
+  #
+  #     for i in a do end
+  #                ^^
+  def do_keyword_loc; end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # The location of the `end` keyword.
+  #
+  #     for i in a end
+  #                ^^^
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def for_keyword: () -> String
+  def for_keyword; end
+
+  # The location of the `for` keyword.
+  #
+  #     for i in a end
+  #     ^^^
+  def for_keyword_loc; end
+
+  # def in_keyword: () -> String
+  def in_keyword; end
+
+  # The location of the `in` keyword.
+  #
+  #     for i in a end
+  #           ^^
+  def in_keyword_loc; end
+
+  # The index expression for `for` loops.
+  #
+  #     for i in a end
+  #         ^
+  def index; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the body of statements to execute for each iteration of the loop.
+  #
+  #     for i in a
+  #       foo(i)
+  #       ^^^^^^
+  #     end
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents forwarding all arguments to this method to another method.
+#
+#     def foo(...)
+#       bar(...)
+#           ^^^
+#     end
+class Prism::ForwardingArgumentsNode < ::Prism::Node
+  # Initialize a new ForwardingArgumentsNode node.
+  #
+  # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+#
+#     def foo(...)
+#             ^^^
+#     end
+class Prism::ForwardingParameterNode < ::Prism::Node
+  # Initialize a new ForwardingParameterNode node.
+  #
+  # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword without parentheses or arguments.
+#
+#     super
+#     ^^^^^
+class Prism::ForwardingSuperNode < ::Prism::Node
+  # Initialize a new ForwardingSuperNode node.
+  #
+  # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
+  def initialize(source, node_id, location, flags, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader block: BlockNode?
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator for assignment to a global variable.
+#
+#     $target &&= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::GlobalVariableAndWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableAndWriteNode node.
+  #
+  # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to a global variable using an operator that isn't `=`.
+#
+#     $target += value
+#     ^^^^^^^^^^^^^^^^
+class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableOperatorWriteNode node.
+  #
+  # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a global variable.
+#
+#     $target ||= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::GlobalVariableOrWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableOrWriteNode node.
+  #
+  # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents referencing a global variable.
+#
+#     $foo
+#     ^^^^
+class Prism::GlobalVariableReadNode < ::Prism::Node
+  # Initialize a new GlobalVariableReadNode node.
+  #
+  # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a global variable in a context that doesn't have an explicit value.
+#
+#     $foo, $bar = baz
+#     ^^^^  ^^^^
+class Prism::GlobalVariableTargetNode < ::Prism::Node
+  # Initialize a new GlobalVariableTargetNode node.
+  #
+  # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a global variable.
+#
+#     $foo = 1
+#     ^^^^^^^^
+class Prism::GlobalVariableWriteNode < ::Prism::Node
+  # Initialize a new GlobalVariableWriteNode node.
+  #
+  # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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 = :bar  # name `:$foo`
+  #
+  #     $_Test = 123 # name `:$_Test`
+  def name; end
+
+  # The location of the global variable's name.
+  #
+  #     $foo = :bar
+  #     ^^^^
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     $foo = :bar
+  #          ^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     $foo = :bar
+  #            ^^^^
+  #
+  #     $-xyz = 123
+  #             ^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a hash literal.
+#
+#     { a => b }
+#     ^^^^^^^^^^
+class Prism::HashNode < ::Prism::Node
+  # Initialize a new HashNode node.
+  #
+  # @return [HashNode] a new instance of HashNode
+  def initialize(source, node_id, location, flags, opening_loc, elements, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # The location of the closing brace.
+  #
+  #     { a => b }
+  #              ^
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
+  #
+  #     { a: b }
+  #       ^^^^
+  #
+  #     { **foo }
+  #       ^^^^^
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # The location of the opening brace.
+  #
+  #     { a => b }
+  #     ^
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a hash pattern in pattern matching.
+#
+#     foo => { a: 1, b: 2 }
+#            ^^^^^^^^^^^^^^
+#
+#     foo => { a: 1, b: 2, **c }
+#            ^^^^^^^^^^^^^^^^^^^
+class Prism::HashPatternNode < ::Prism::Node
+  # Initialize a new HashPatternNode node.
+  #
+  # @return [HashPatternNode] a new instance of HashPatternNode
+  def initialize(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String?
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader constant: Prism::node?
+  def constant; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[AssocNode]
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  def opening_loc; end
+
+  # attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
+  def rest; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+module Prism::HeredocQuery
+  # Returns true if this node was represented as a heredoc in the source code.
+  #
+  # @return [Boolean]
+  def heredoc?; end
+end
+
+# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
+#
+#     bar if foo
+#     ^^^^^^^^^^
+#
+#     if foo then bar end
+#     ^^^^^^^^^^^^^^^^^^^
+#
+#     foo ? bar : baz
+#     ^^^^^^^^^^^^^^^
+class Prism::IfNode < ::Prism::Node
+  # Initialize a new IfNode node.
+  #
+  # @return [IfNode] a new instance of IfNode
+  def initialize(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # Returns the subsequent if/elsif/else clause of the if node. This method is
+  # deprecated in favor of #subsequent.
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String?
+  def end_keyword; end
+
+  # The location of the `end` keyword if present, `nil` otherwise.
+  #
+  #     if foo
+  #       bar
+  #     end
+  #     ^^^
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def if_keyword: () -> String?
+  def if_keyword; end
+
+  # The location of the `if` keyword if present.
+  #
+  #     bar if foo
+  #         ^^
+  #
+  # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
+  def if_keyword_loc; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  def newline_flag!(lines); end
+
+  # The node for the condition the `IfNode` is testing.
+  #
+  #     if foo
+  #        ^^^
+  #       bar
+  #     end
+  #
+  #     bar if foo
+  #            ^^^
+  #
+  #     foo ? bar : baz
+  #     ^^^
+  def predicate; end
+
+  # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
+  #
+  #     if foo
+  #       bar
+  #       ^^^
+  #       baz
+  #       ^^^
+  #     end
+  def statements; end
+
+  # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
+  #
+  #     if foo
+  #       bar
+  #     elsif baz
+  #     ^^^^^^^^^
+  #       qux
+  #       ^^^
+  #     end
+  #     ^^^
+  #
+  #     if foo then bar else baz end
+  #                     ^^^^^^^^^^^^
+  def subsequent; end
+
+  # def then_keyword: () -> String?
+  def then_keyword; end
+
+  # The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
+  #
+  #     if foo then bar end
+  #            ^^^^
+  #
+  #     a ? b : c
+  #       ^
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an imaginary number literal.
+#
+#     1.0i
+#     ^^^^
+class Prism::ImaginaryNode < ::Prism::Node
+  # Initialize a new ImaginaryNode node.
+  #
+  # @return [ImaginaryNode] a new instance of ImaginaryNode
+  def initialize(source, node_id, location, flags, numeric); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader numeric: FloatNode | IntegerNode | RationalNode
+  def numeric; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # Returns the value of the node as a Ruby Complex.
+  sig { returns(Complex) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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: }
+#              ^^^^
+class Prism::ImplicitNode < ::Prism::Node
+  # Initialize a new ImplicitNode node.
+  #
+  # @return [ImplicitNode] a new instance of ImplicitNode
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node) -> ImplicitNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#        ^
+class Prism::ImplicitRestNode < ::Prism::Node
+  # Initialize a new ImplicitRestNode node.
+  #
+  # @return [ImplicitRestNode] a new instance of ImplicitRestNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `in` keyword in a case statement.
+#
+#     case a; in b then c end
+#             ^^^^^^^^^^^
+class Prism::InNode < ::Prism::Node
+  # Initialize a new InNode node.
+  #
+  # @return [InNode] a new instance of InNode
+  def initialize(source, node_id, location, flags, pattern, statements, in_loc, then_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def in: () -> String
+  def in; end
+
+  # attr_reader in_loc: Location
+  def in_loc; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader pattern: Prism::node
+  def pattern; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # def then: () -> String?
+  def then; end
+
+  # attr_reader then_loc: Location?
+  def then_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `&&=` operator on a call to the `[]` method.
+#
+#     foo.bar[baz] &&= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+class Prism::IndexAndWriteNode < ::Prism::Node
+  # Initialize a new IndexAndWriteNode node.
+  #
+  # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexAndWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of an assignment operator on a call to `[]`.
+#
+#     foo.bar[baz] += value
+#     ^^^^^^^^^^^^^^^^^^^^^
+class Prism::IndexOperatorWriteNode < ::Prism::Node
+  # Initialize a new IndexOperatorWriteNode node.
+  #
+  # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader binary_operator: Symbol
+  sig { returns(Symbol) }
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  sig { returns(Prism::Location) }
+  def binary_operator_loc; end
+
+  # attr_reader block: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      binary_operator: Symbol,
+      binary_operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOperatorWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator on a call to `[]`.
+#
+#     foo.bar[baz] ||= value
+#     ^^^^^^^^^^^^^^^^^^^^^^
+class Prism::IndexOrWriteNode < ::Prism::Node
+  # Initialize a new IndexOrWriteNode node.
+  #
+  # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def call_operator: () -> String?
+  sig { returns(T.nilable(String)) }
+  def call_operator; end
+
+  # attr_reader call_operator_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def call_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: T.nilable(Prism::Node),
+      call_operator_loc: T.nilable(Prism::Location),
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node),
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::IndexOrWriteNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # attr_reader receiver: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#         ^^^^^^^^
+class Prism::IndexTargetNode < ::Prism::Node
+  # Initialize a new IndexTargetNode node.
+  #
+  # @return [IndexTargetNode] a new instance of IndexTargetNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  sig { returns(T.nilable(Prism::ArgumentsNode)) }
+  def arguments; end
+
+  # def attribute_write?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def attribute_write?; end
+
+  # attr_reader block: Prism::node?
+  sig { returns(T.nilable(Prism::Node)) }
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?) -> IndexTargetNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      receiver: Prism::Node,
+      opening_loc: Prism::Location,
+      arguments: T.nilable(Prism::ArgumentsNode),
+      closing_loc: Prism::Location,
+      block: T.nilable(Prism::Node)
+    ).returns(Prism::IndexTargetNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def ignore_visibility?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_visibility?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # attr_reader receiver: Prism::node
+  sig { returns(Prism::Node) }
+  def receiver; end
+
+  # def safe_navigation?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def safe_navigation?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def variable_call?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def variable_call?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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 #.
+class Prism::InlineComment < ::Prism::Comment
+  # Returns a string representation of this comment.
+  sig { returns(String) }
+  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]
+  sig { override.returns(T::Boolean) }
+  def trailing?; end
+end
+
+# This visitor is responsible for composing the strings that get returned by
+# the various #inspect methods defined on each of the nodes.
+class Prism::InspectVisitor < ::Prism::Visitor
+  # Initializes a new instance of the InspectVisitor.
+  #
+  # @return [InspectVisitor] a new instance of InspectVisitor
+  sig { params(indent: String).void }
+  def initialize(indent = T.unsafe(nil)); end
+
+  # The list of commands that we need to execute in order to compose the
+  # final string.
+  def commands; end
+
+  # Compose the final string.
+  sig { returns(String) }
+  def compose; end
+
+  # The current prefix string.
+  def indent; end
+
+  # Inspect a AliasGlobalVariableNode node.
+  def visit_alias_global_variable_node(node); end
+
+  # Inspect a AliasMethodNode node.
+  def visit_alias_method_node(node); end
+
+  # Inspect a AlternationPatternNode node.
+  def visit_alternation_pattern_node(node); end
+
+  # Inspect a AndNode node.
+  def visit_and_node(node); end
+
+  # Inspect a ArgumentsNode node.
+  def visit_arguments_node(node); end
+
+  # Inspect a ArrayNode node.
+  def visit_array_node(node); end
+
+  # Inspect a ArrayPatternNode node.
+  def visit_array_pattern_node(node); end
+
+  # Inspect a AssocNode node.
+  def visit_assoc_node(node); end
+
+  # Inspect a AssocSplatNode node.
+  def visit_assoc_splat_node(node); end
+
+  # Inspect a BackReferenceReadNode node.
+  def visit_back_reference_read_node(node); end
+
+  # Inspect a BeginNode node.
+  def visit_begin_node(node); end
+
+  # Inspect a BlockArgumentNode node.
+  def visit_block_argument_node(node); end
+
+  # Inspect a BlockLocalVariableNode node.
+  def visit_block_local_variable_node(node); end
+
+  # Inspect a BlockNode node.
+  def visit_block_node(node); end
+
+  # Inspect a BlockParameterNode node.
+  def visit_block_parameter_node(node); end
+
+  # Inspect a BlockParametersNode node.
+  def visit_block_parameters_node(node); end
+
+  # Inspect a BreakNode node.
+  def visit_break_node(node); end
+
+  # Inspect a CallAndWriteNode node.
+  def visit_call_and_write_node(node); end
+
+  # Inspect a CallNode node.
+  def visit_call_node(node); end
+
+  # Inspect a CallOperatorWriteNode node.
+  def visit_call_operator_write_node(node); end
+
+  # Inspect a CallOrWriteNode node.
+  def visit_call_or_write_node(node); end
+
+  # Inspect a CallTargetNode node.
+  def visit_call_target_node(node); end
+
+  # Inspect a CapturePatternNode node.
+  def visit_capture_pattern_node(node); end
+
+  # Inspect a CaseMatchNode node.
+  def visit_case_match_node(node); end
+
+  # Inspect a CaseNode node.
+  def visit_case_node(node); end
+
+  # Inspect a ClassNode node.
+  def visit_class_node(node); end
+
+  # Inspect a ClassVariableAndWriteNode node.
+  def visit_class_variable_and_write_node(node); end
+
+  # Inspect a ClassVariableOperatorWriteNode node.
+  def visit_class_variable_operator_write_node(node); end
+
+  # Inspect a ClassVariableOrWriteNode node.
+  def visit_class_variable_or_write_node(node); end
+
+  # Inspect a ClassVariableReadNode node.
+  def visit_class_variable_read_node(node); end
+
+  # Inspect a ClassVariableTargetNode node.
+  def visit_class_variable_target_node(node); end
+
+  # Inspect a ClassVariableWriteNode node.
+  def visit_class_variable_write_node(node); end
+
+  # Inspect a ConstantAndWriteNode node.
+  def visit_constant_and_write_node(node); end
+
+  # Inspect a ConstantOperatorWriteNode node.
+  def visit_constant_operator_write_node(node); end
+
+  # Inspect a ConstantOrWriteNode node.
+  def visit_constant_or_write_node(node); end
+
+  # Inspect a ConstantPathAndWriteNode node.
+  def visit_constant_path_and_write_node(node); end
+
+  # Inspect a ConstantPathNode node.
+  def visit_constant_path_node(node); end
+
+  # Inspect a ConstantPathOperatorWriteNode node.
+  def visit_constant_path_operator_write_node(node); end
+
+  # Inspect a ConstantPathOrWriteNode node.
+  def visit_constant_path_or_write_node(node); end
+
+  # Inspect a ConstantPathTargetNode node.
+  def visit_constant_path_target_node(node); end
+
+  # Inspect a ConstantPathWriteNode node.
+  def visit_constant_path_write_node(node); end
+
+  # Inspect a ConstantReadNode node.
+  def visit_constant_read_node(node); end
+
+  # Inspect a ConstantTargetNode node.
+  def visit_constant_target_node(node); end
+
+  # Inspect a ConstantWriteNode node.
+  def visit_constant_write_node(node); end
+
+  # Inspect a DefNode node.
+  def visit_def_node(node); end
+
+  # Inspect a DefinedNode node.
+  def visit_defined_node(node); end
+
+  # Inspect a ElseNode node.
+  def visit_else_node(node); end
+
+  # Inspect a EmbeddedStatementsNode node.
+  def visit_embedded_statements_node(node); end
+
+  # Inspect a EmbeddedVariableNode node.
+  def visit_embedded_variable_node(node); end
+
+  # Inspect a EnsureNode node.
+  def visit_ensure_node(node); end
+
+  # Inspect a FalseNode node.
+  def visit_false_node(node); end
+
+  # Inspect a FindPatternNode node.
+  def visit_find_pattern_node(node); end
+
+  # Inspect a FlipFlopNode node.
+  def visit_flip_flop_node(node); end
+
+  # Inspect a FloatNode node.
+  def visit_float_node(node); end
+
+  # Inspect a ForNode node.
+  def visit_for_node(node); end
+
+  # Inspect a ForwardingArgumentsNode node.
+  def visit_forwarding_arguments_node(node); end
+
+  # Inspect a ForwardingParameterNode node.
+  def visit_forwarding_parameter_node(node); end
+
+  # Inspect a ForwardingSuperNode node.
+  def visit_forwarding_super_node(node); end
+
+  # Inspect a GlobalVariableAndWriteNode node.
+  def visit_global_variable_and_write_node(node); end
+
+  # Inspect a GlobalVariableOperatorWriteNode node.
+  def visit_global_variable_operator_write_node(node); end
+
+  # Inspect a GlobalVariableOrWriteNode node.
+  def visit_global_variable_or_write_node(node); end
+
+  # Inspect a GlobalVariableReadNode node.
+  def visit_global_variable_read_node(node); end
+
+  # Inspect a GlobalVariableTargetNode node.
+  def visit_global_variable_target_node(node); end
+
+  # Inspect a GlobalVariableWriteNode node.
+  def visit_global_variable_write_node(node); end
+
+  # Inspect a HashNode node.
+  def visit_hash_node(node); end
+
+  # Inspect a HashPatternNode node.
+  def visit_hash_pattern_node(node); end
+
+  # Inspect a IfNode node.
+  def visit_if_node(node); end
+
+  # Inspect a ImaginaryNode node.
+  def visit_imaginary_node(node); end
+
+  # Inspect a ImplicitNode node.
+  def visit_implicit_node(node); end
+
+  # Inspect a ImplicitRestNode node.
+  def visit_implicit_rest_node(node); end
+
+  # Inspect a InNode node.
+  def visit_in_node(node); end
+
+  # Inspect a IndexAndWriteNode node.
+  def visit_index_and_write_node(node); end
+
+  # Inspect a IndexOperatorWriteNode node.
+  def visit_index_operator_write_node(node); end
+
+  # Inspect a IndexOrWriteNode node.
+  def visit_index_or_write_node(node); end
+
+  # Inspect a IndexTargetNode node.
+  def visit_index_target_node(node); end
+
+  # Inspect a InstanceVariableAndWriteNode node.
+  def visit_instance_variable_and_write_node(node); end
+
+  # Inspect a InstanceVariableOperatorWriteNode node.
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Inspect a InstanceVariableOrWriteNode node.
+  def visit_instance_variable_or_write_node(node); end
+
+  # Inspect a InstanceVariableReadNode node.
+  def visit_instance_variable_read_node(node); end
+
+  # Inspect a InstanceVariableTargetNode node.
+  def visit_instance_variable_target_node(node); end
+
+  # Inspect a InstanceVariableWriteNode node.
+  def visit_instance_variable_write_node(node); end
+
+  # Inspect a IntegerNode node.
+  def visit_integer_node(node); end
+
+  # Inspect a InterpolatedMatchLastLineNode node.
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Inspect a InterpolatedRegularExpressionNode node.
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Inspect a InterpolatedStringNode node.
+  def visit_interpolated_string_node(node); end
+
+  # Inspect a InterpolatedSymbolNode node.
+  def visit_interpolated_symbol_node(node); end
+
+  # Inspect a InterpolatedXStringNode node.
+  def visit_interpolated_x_string_node(node); end
+
+  # Inspect a ItLocalVariableReadNode node.
+  def visit_it_local_variable_read_node(node); end
+
+  # Inspect a ItParametersNode node.
+  def visit_it_parameters_node(node); end
+
+  # Inspect a KeywordHashNode node.
+  def visit_keyword_hash_node(node); end
+
+  # Inspect a KeywordRestParameterNode node.
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Inspect a LambdaNode node.
+  def visit_lambda_node(node); end
+
+  # Inspect a LocalVariableAndWriteNode node.
+  def visit_local_variable_and_write_node(node); end
+
+  # Inspect a LocalVariableOperatorWriteNode node.
+  def visit_local_variable_operator_write_node(node); end
+
+  # Inspect a LocalVariableOrWriteNode node.
+  def visit_local_variable_or_write_node(node); end
+
+  # Inspect a LocalVariableReadNode node.
+  def visit_local_variable_read_node(node); end
+
+  # Inspect a LocalVariableTargetNode node.
+  def visit_local_variable_target_node(node); end
+
+  # Inspect a LocalVariableWriteNode node.
+  def visit_local_variable_write_node(node); end
+
+  # Inspect a MatchLastLineNode node.
+  def visit_match_last_line_node(node); end
+
+  # Inspect a MatchPredicateNode node.
+  def visit_match_predicate_node(node); end
+
+  # Inspect a MatchRequiredNode node.
+  def visit_match_required_node(node); end
+
+  # Inspect a MatchWriteNode node.
+  def visit_match_write_node(node); end
+
+  # Inspect a MissingNode node.
+  def visit_missing_node(node); end
+
+  # Inspect a ModuleNode node.
+  def visit_module_node(node); end
+
+  # Inspect a MultiTargetNode node.
+  def visit_multi_target_node(node); end
+
+  # Inspect a MultiWriteNode node.
+  def visit_multi_write_node(node); end
+
+  # Inspect a NextNode node.
+  def visit_next_node(node); end
+
+  # Inspect a NilNode node.
+  def visit_nil_node(node); end
+
+  # Inspect a NoKeywordsParameterNode node.
+  def visit_no_keywords_parameter_node(node); end
+
+  # Inspect a NumberedParametersNode node.
+  def visit_numbered_parameters_node(node); end
+
+  # Inspect a NumberedReferenceReadNode node.
+  def visit_numbered_reference_read_node(node); end
+
+  # Inspect a OptionalKeywordParameterNode node.
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Inspect a OptionalParameterNode node.
+  def visit_optional_parameter_node(node); end
+
+  # Inspect a OrNode node.
+  def visit_or_node(node); end
+
+  # Inspect a ParametersNode node.
+  def visit_parameters_node(node); end
+
+  # Inspect a ParenthesesNode node.
+  def visit_parentheses_node(node); end
+
+  # Inspect a PinnedExpressionNode node.
+  def visit_pinned_expression_node(node); end
+
+  # Inspect a PinnedVariableNode node.
+  def visit_pinned_variable_node(node); end
+
+  # Inspect a PostExecutionNode node.
+  def visit_post_execution_node(node); end
+
+  # Inspect a PreExecutionNode node.
+  def visit_pre_execution_node(node); end
+
+  # Inspect a ProgramNode node.
+  def visit_program_node(node); end
+
+  # Inspect a RangeNode node.
+  def visit_range_node(node); end
+
+  # Inspect a RationalNode node.
+  def visit_rational_node(node); end
+
+  # Inspect a RedoNode node.
+  def visit_redo_node(node); end
+
+  # Inspect a RegularExpressionNode node.
+  def visit_regular_expression_node(node); end
+
+  # Inspect a RequiredKeywordParameterNode node.
+  def visit_required_keyword_parameter_node(node); end
+
+  # Inspect a RequiredParameterNode node.
+  def visit_required_parameter_node(node); end
+
+  # Inspect a RescueModifierNode node.
+  def visit_rescue_modifier_node(node); end
+
+  # Inspect a RescueNode node.
+  def visit_rescue_node(node); end
+
+  # Inspect a RestParameterNode node.
+  def visit_rest_parameter_node(node); end
+
+  # Inspect a RetryNode node.
+  def visit_retry_node(node); end
+
+  # Inspect a ReturnNode node.
+  def visit_return_node(node); end
+
+  # Inspect a SelfNode node.
+  def visit_self_node(node); end
+
+  # Inspect a ShareableConstantNode node.
+  def visit_shareable_constant_node(node); end
+
+  # Inspect a SingletonClassNode node.
+  def visit_singleton_class_node(node); end
+
+  # Inspect a SourceEncodingNode node.
+  def visit_source_encoding_node(node); end
+
+  # Inspect a SourceFileNode node.
+  def visit_source_file_node(node); end
+
+  # Inspect a SourceLineNode node.
+  def visit_source_line_node(node); end
+
+  # Inspect a SplatNode node.
+  def visit_splat_node(node); end
+
+  # Inspect a StatementsNode node.
+  def visit_statements_node(node); end
+
+  # Inspect a StringNode node.
+  def visit_string_node(node); end
+
+  # Inspect a SuperNode node.
+  def visit_super_node(node); end
+
+  # Inspect a SymbolNode node.
+  def visit_symbol_node(node); end
+
+  # Inspect a TrueNode node.
+  def visit_true_node(node); end
+
+  # Inspect a UndefNode node.
+  def visit_undef_node(node); end
+
+  # Inspect a UnlessNode node.
+  def visit_unless_node(node); end
+
+  # Inspect a UntilNode node.
+  def visit_until_node(node); end
+
+  # Inspect a WhenNode node.
+  def visit_when_node(node); end
+
+  # Inspect a WhileNode node.
+  def visit_while_node(node); end
+
+  # Inspect a XStringNode node.
+  def visit_x_string_node(node); end
+
+  # Inspect a YieldNode node.
+  def visit_yield_node(node); end
+
+  private
+
+  # Compose a string representing the given inner location field.
+  def inspect_location(location); end
+
+  # Compose a header for the given node.
+  def inspect_node(name, node); end
+
+  class << self
+    # Compose an inspect string for the given node.
+    sig { params(node: Prism::Node).returns(String) }
+    def compose(node); end
+  end
+end
+
+# Most of the time, we can simply pass down the indent to the next node.
+# However, when we are inside a list we want some extra special formatting
+# when we hit an element in that list. In this case, we have a special
+# command that replaces the subsequent indent with the given value.
+class Prism::InspectVisitor::Replace
+  # @return [Replace] a new instance of Replace
+  def initialize(value); end
+
+  def value; end
+end
+
+# Represents the use of the `&&=` operator for assignment to an instance variable.
+#
+#     @target &&= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::InstanceVariableAndWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableAndWriteNode node.
+  #
+  # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to an instance variable using an operator that isn't `=`.
+#
+#     @target += value
+#     ^^^^^^^^^^^^^^^^
+class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableOperatorWriteNode node.
+  #
+  # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> InstanceVariableOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to an instance variable.
+#
+#     @target ||= value
+#     ^^^^^^^^^^^^^^^^^
+class Prism::InstanceVariableOrWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableOrWriteNode node.
+  #
+  # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents referencing an instance variable.
+#
+#     @foo
+#     ^^^^
+class Prism::InstanceVariableReadNode < ::Prism::Node
+  # Initialize a new InstanceVariableReadNode node.
+  #
+  # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable in a context that doesn't have an explicit value.
+#
+#     @foo, @bar = baz
+#     ^^^^  ^^^^
+class Prism::InstanceVariableTargetNode < ::Prism::Node
+  # Initialize a new InstanceVariableTargetNode node.
+  #
+  # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to an instance variable.
+#
+#     @foo = 1
+#     ^^^^^^^^
+class Prism::InstanceVariableWriteNode < ::Prism::Node
+  # Initialize a new InstanceVariableWriteNode node.
+  #
+  # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
+  def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> InstanceVariableWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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 = :y       # name `:@x`
+  #
+  #     @_foo = "bar" # name `@_foo`
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     @_x = 1
+  #     ^^^
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     @x = y
+  #        ^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     @foo = :bar
+  #            ^^^^
+  #
+  #     @_x = 1234
+  #           ^^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for integer nodes that correspond to the base of the integer.
+module Prism::IntegerBaseFlags; end
+
+# 0b prefix
+Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
+
+# 0d or no prefix
+Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0x prefix
+Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0o or 0 prefix
+Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an integer number literal.
+#
+#     1
+#     ^
+class Prism::IntegerNode < ::Prism::Node
+  # Initialize a new IntegerNode node.
+  #
+  # @return [IntegerNode] a new instance of IntegerNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def binary?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Integer) -> IntegerNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      value: Integer
+    ).returns(Prism::IntegerNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def decimal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def hexadecimal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def octal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def octal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value of the integer literal as a number.
+  sig { returns(Integer) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#        ^^^^^^^^^^^^^^^^
+class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new InterpolatedMatchLastLineNode node.
+  #
+  # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedMatchLastLineNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedMatchLastLineNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  def newline_flag!(lines); end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a regular expression literal that contains interpolation.
+#
+#     /foo #{bar} baz/
+#     ^^^^^^^^^^^^^^^^
+class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new InterpolatedRegularExpressionNode node.
+  #
+  # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedRegularExpressionNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
+      closing_loc: Prism::Location
+    ).returns(Prism::InterpolatedRegularExpressionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  def newline_flag!(lines); end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a string literal that contains interpolation.
+#
+#     "foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^
+class Prism::InterpolatedStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new InterpolatedStringNode node.
+  #
+  # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], ?closing_loc: Location?) -> InterpolatedStringNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
+      closing_loc: T.nilable(Prism::Location)
+    ).returns(Prism::InterpolatedStringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], closing_loc: Location? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  def newline_flag!(lines); end
+
+  # def opening: () -> String?
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode]
+  sig do
+    returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)])
+  end
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
+module Prism::InterpolatedStringNodeFlags; end
+
+Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
+
+# Represents a symbol literal that contains interpolation.
+#
+#     :"foo #{bar} baz"
+#     ^^^^^^^^^^^^^^^^^
+class Prism::InterpolatedSymbolNode < ::Prism::Node
+  # Initialize a new InterpolatedSymbolNode node.
+  #
+  # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String?
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?) -> InterpolatedSymbolNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  def newline_flag!(lines); end
+
+  # def opening: () -> String?
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an xstring literal that contains interpolation.
+#
+#     `foo #{bar} baz`
+#     ^^^^^^^^^^^^^^^^
+class Prism::InterpolatedXStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new InterpolatedXStringNode node.
+  #
+  # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
+  def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedXStringNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  def newline_flag!(lines); end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+  def parts; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents reading from the implicit `it` local variable.
+#
+#     -> { it }
+#          ^^
+class Prism::ItLocalVariableReadNode < ::Prism::Node
+  # Initialize a new ItLocalVariableReadNode node.
+  #
+  # @return [ItLocalVariableReadNode] a new instance of ItLocalVariableReadNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItLocalVariableReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
+#
+#     -> { it + it }
+#     ^^^^^^^^^^^^^^
+class Prism::ItParametersNode < ::Prism::Node
+  # Initialize a new ItParametersNode node.
+  #
+  # @return [ItParametersNode] a new instance of ItParametersNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItParametersNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a hash literal without opening and closing braces.
+#
+#     foo(a: b)
+#         ^^^^
+class Prism::KeywordHashNode < ::Prism::Node
+  # Initialize a new KeywordHashNode node.
+  #
+  # @return [KeywordHashNode] a new instance of KeywordHashNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).void
+  end
+  def initialize(source, node_id, location, flags, elements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode]) -> KeywordHashNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]
+    ).returns(Prism::KeywordHashNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # attr_reader elements: Array[AssocNode | AssocSplatNode]
+  sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
+  def elements; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def symbol_keys?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def symbol_keys?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for keyword hash nodes.
+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
+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
+class Prism::KeywordRestParameterNode < ::Prism::Node
+  # Initialize a new KeywordRestParameterNode node.
+  #
+  # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> KeywordRestParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::KeywordRestParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents using a lambda literal (not the lambda method call).
+#
+#     ->(value) { value * 2 }
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+class Prism::LambdaNode < ::Prism::Node
+  # Initialize a new LambdaNode node.
+  #
+  # @return [LambdaNode] a new instance of LambdaNode
+  def initialize(source, node_id, location, flags, locals, operator_loc, opening_loc, closing_loc, parameters, body); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: Prism::node?, ?body: Prism::node?) -> LambdaNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Prism::node?, body: Prism::node? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader parameters: Prism::node?
+  def parameters; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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.
+class Prism::LexCompat
+  # @return [LexCompat] a new instance of LexCompat
+  def initialize(source, **options); end
+
+  # Returns the value of attribute options.
+  def options; end
+
+  def result; end
+
+  # Returns the value of attribute source.
+  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.
+class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
+  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.
+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.
+    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.
+class Prism::LexCompat::Heredoc::DashHeredoc
+  # @return [DashHeredoc] a new instance of DashHeredoc
+  def initialize(split); end
+
+  def <<(token); end
+  def split; end
+  def to_a; end
+  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.
+class Prism::LexCompat::Heredoc::DedentingHeredoc
+  # @return [DedentingHeredoc] a new instance of DedentingHeredoc
+  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.
+  def <<(token); end
+
+  # Returns the value of attribute dedent.
+  def dedent; end
+
+  # Returns the value of attribute dedent_next.
+  def dedent_next; end
+
+  # Returns the value of attribute embexpr_balance.
+  def embexpr_balance; end
+
+  def to_a; end
+
+  # Returns the value of attribute tokens.
+  def tokens; end
+end
+
+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.
+class Prism::LexCompat::Heredoc::PlainHeredoc
+  # @return [PlainHeredoc] a new instance of PlainHeredoc
+  def initialize; end
+
+  def <<(token); end
+  def to_a; end
+  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.
+class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
+  def ==(other); end
+end
+
+# Tokens where state should be ignored
+# used for :on_comment, :on_heredoc_end, :on_embexpr_end
+class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
+  def ==(other); end
+end
+
+# Ignored newlines can occasionally have a LABEL state attached to them, so
+# we compare the state differently here.
+class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
+  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.
+class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
+  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.
+Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
+
+# A result class specialized for holding tokens produced by the lexer.
+class Prism::LexCompat::Result < ::Prism::Result
+  # Create a new lex compat result object with the given values.
+  #
+  # @return [Result] a new instance of Result
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for Result.
+  def deconstruct_keys(keys); end
+
+  # The list of tokens that were produced by the lexer.
+  def value; end
+end
+
+# 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.
+class Prism::LexCompat::Token < ::SimpleDelegator
+  # The type of the token.
+  def event; end
+
+  # The location of the token in the source.
+  def location; end
+
+  # The state of the lexer when this token was produced.
+  def state; end
+
+  # The slice of the source that this token represents.
+  def value; end
+end
+
+# This is a result specific to the `lex` and `lex_file` methods.
+class Prism::LexResult < ::Prism::Result
+  # Create a new lex result object with the given values.
+  #
+  # @return [LexResult] a new instance of LexResult
+  sig do
+    params(
+      value: T::Array[T.untyped],
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for LexResult.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The list of tokens that were parsed from the source code.
+  sig { returns(T::Array[T.untyped]) }
+  def value; end
+end
+
+# This is a class that wraps the Ripper lexer to produce almost exactly the
+# same tokens.
+class Prism::LexRipper
+  # @return [LexRipper] a new instance of LexRipper
+  def initialize(source); end
+
+  def result; end
+  def source; end
+
+  private
+
+  def lex(source); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a local variable.
+#
+#     target &&= value
+#     ^^^^^^^^^^^^^^^^
+class Prism::LocalVariableAndWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableAndWriteNode node.
+  #
+  # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
+  def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableAndWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  def depth; end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents assigning to a local variable using an operator that isn't `=`.
+#
+#     target += value
+#     ^^^^^^^^^^^^^^^
+class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableOperatorWriteNode node.
+  #
+  # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
+  def initialize(source, node_id, location, flags, name_loc, binary_operator_loc, value, name, binary_operator, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader binary_operator: Symbol
+  def binary_operator; end
+
+  # attr_reader binary_operator_loc: Location
+  def binary_operator_loc; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer) -> LocalVariableOperatorWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  def depth; end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # Returns the binary operator used to modify the receiver. This method is
+  # deprecated in favor of #binary_operator.
+  def operator; end
+
+  # Returns the location of the binary operator used to modify the receiver.
+  # This method is deprecated in favor of #binary_operator_loc.
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||=` operator for assignment to a local variable.
+#
+#     target ||= value
+#     ^^^^^^^^^^^^^^^^
+class Prism::LocalVariableOrWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableOrWriteNode node.
+  #
+  # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
+  def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableOrWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  def depth; end
+
+  def desugar; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # attr_reader name_loc: Location
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^
+class Prism::LocalVariableReadNode < ::Prism::Node
+  # Initialize a new LocalVariableReadNode node.
+  #
+  # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
+  def initialize(source, node_id, location, flags, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
+  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).
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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`
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a local variable in a context that doesn't have an explicit value.
+#
+#     foo, bar = baz
+#     ^^^  ^^^
+class Prism::LocalVariableTargetNode < ::Prism::Node
+  # Initialize a new LocalVariableTargetNode node.
+  #
+  # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
+  def initialize(source, node_id, location, flags, name, depth); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
+  def deconstruct_keys(keys); end
+
+  # attr_reader depth: Integer
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing to a local variable.
+#
+#     foo = 1
+#     ^^^^^^^
+class Prism::LocalVariableWriteNode < ::Prism::Node
+  # Initialize a new LocalVariableWriteNode node.
+  #
+  # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
+  def initialize(source, node_id, location, flags, name, depth, name_loc, value, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # The number of semantic scopes we have to traverse to find the declaration of this variable.
+  #
+  #     foo = 1         # depth 0
+  #
+  #     tap { foo = 1 } # 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).
+  def depth; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+  #
+  #     foo = :bar # name `:foo`
+  #
+  #     abc = 123  # name `:abc`
+  def name; end
+
+  # The location of the variable name.
+  #
+  #     foo = :bar
+  #     ^^^
+  def name_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `=` operator.
+  #
+  #     x = :y
+  #       ^
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     foo = :bar
+  #           ^^^^
+  #
+  #     abc = 1234
+  #           ^^^^
+  #
+  # Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
+  #
+  #     foo = foo
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents a location in the source.
+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
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
+  def initialize(source, start_offset, length); end
+
+  # Returns true if the given other location is equal to this location.
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  # Join this location with the first occurrence of the string in the source
+  # that occurs after this location on the same line, and return the new
+  # location. This will raise an error if the string does not exist.
+  sig { params(string: String).returns(Prism::Location) }
+  def adjoin(string); end
+
+  # Returns a new location that is the result of chopping off the last byte.
+  sig { returns(Prism::Location) }
+  def chop; end
+
+  # Returns all comments that are associated with this location (both leading
+  # and trailing comments).
+  sig { returns(T::Array[Prism::Comment]) }
+  def comments; end
+
+  # Create a new location object with the given options.
+  sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
+  def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
+
+  # Implement the hash pattern matching interface for Location.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  sig { returns(Integer) }
+  def end_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # ends.
+  sig { returns(Integer) }
+  def end_character_offset; end
+
+  # The column number in code units of the given encoding where this location
+  # ends from the start of the line.
+  sig { params(encoding: Encoding).returns(Integer) }
+  def end_code_units_column(encoding = T.unsafe(nil)); end
+
+  # The offset from the start of the file in code units of the given encoding.
+  sig { params(encoding: Encoding).returns(Integer) }
+  def end_code_units_offset(encoding = T.unsafe(nil)); end
+
+  # The column number in bytes where this location ends from the start of the
+  # line.
+  sig { returns(Integer) }
+  def end_column; end
+
+  # The line number where this location ends.
+  sig { returns(Integer) }
+  def end_line; end
+
+  # The byte offset from the beginning of the source where this location ends.
+  sig { returns(Integer) }
+  def end_offset; end
+
+  # Returns a string representation of this location.
+  sig { returns(String) }
+  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.
+  sig { params(other: Prism::Location).returns(Prism::Location) }
+  def join(other); end
+
+  # Attach a comment to the leading comments of this location.
+  sig { params(comment: Prism::Comment).void }
+  def leading_comment(comment); end
+
+  # These are the comments that are associated with this location that exist
+  # before the start of this location.
+  sig { returns(T::Array[Prism::Comment]) }
+  def leading_comments; end
+
+  # The length of this location in bytes.
+  sig { returns(Integer) }
+  def length; end
+
+  # Implement the pretty print interface for Location.
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # The source code that this location represents.
+  sig { returns(String) }
+  def slice; end
+
+  # The source code that this location represents starting from the beginning
+  # of the line that this location starts on to the end of the line that this
+  # location ends on.
+  def slice_lines; end
+
+  # Returns all of the lines of the source code associated with this location.
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
+  # The column number in characters where this location ends from the start of
+  # the line.
+  sig { returns(Integer) }
+  def start_character_column; end
+
+  # The character offset from the beginning of the source where this location
+  # starts.
+  sig { returns(Integer) }
+  def start_character_offset; end
+
+  # The column number in code units of the given encoding where this location
+  # starts from the start of the line.
+  sig { params(encoding: Encoding).returns(Integer) }
+  def start_code_units_column(encoding = T.unsafe(nil)); end
+
+  # The offset from the start of the file in code units of the given encoding.
+  sig { params(encoding: Encoding).returns(Integer) }
+  def start_code_units_offset(encoding = T.unsafe(nil)); end
+
+  # The column number in bytes where this location starts from the start of
+  # the line.
+  sig { returns(Integer) }
+  def start_column; end
+
+  # The line number where this location starts.
+  sig { returns(Integer) }
+  def start_line; end
+
+  # The content of the line where this location starts before this location.
+  sig { returns(String) }
+  def start_line_slice; end
+
+  # The byte offset from the beginning of the source where this location
+  # starts.
+  sig { returns(Integer) }
+  def start_offset; end
+
+  # Attach a comment to the trailing comments of this location.
+  sig { params(comment: Prism::Comment).void }
+  def trailing_comment(comment); end
+
+  # These are the comments that are associated with this location that exist
+  # after the end of this location.
+  sig { returns(T::Array[Prism::Comment]) }
+  def trailing_comments; end
+
+  protected
+
+  # A Source object that is used to determine more information from the given
+  # offset and length.
+  sig { returns(Prism::Source) }
+  def source; end
+end
+
+# Flags for while and until loop nodes.
+module Prism::LoopFlags; end
+
+# a loop after a begin statement, so the body is executed first before the condition
+Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer)
+
+# This represents a magic comment that was encountered during parsing.
+class Prism::MagicComment
+  # Create a new magic comment object with the given key and value locations.
+  #
+  # @return [MagicComment] a new instance of MagicComment
+  sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
+  def initialize(key_loc, value_loc); end
+
+  # Implement the hash pattern matching interface for MagicComment.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this magic comment.
+  sig { returns(String) }
+  def inspect; end
+
+  # Returns the key of the magic comment by slicing it from the source code.
+  sig { returns(String) }
+  def key; end
+
+  # A Location object representing the location of the key in the source.
+  sig { returns(Prism::Location) }
+  def key_loc; end
+
+  # Returns the value of the magic comment by slicing it from the source code.
+  sig { returns(String) }
+  def value; end
+
+  # A Location object representing the location of the value in the source.
+  sig { returns(Prism::Location) }
+  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
+#        ^^^^^^
+class Prism::MatchLastLineNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new MatchLastLineNode node.
+  #
+  # @return [MatchLastLineNode] a new instance of MatchLastLineNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> MatchLastLineNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::MatchLastLineNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the modifier `in` operator.
+#
+#     foo in bar
+#     ^^^^^^^^^^
+class Prism::MatchPredicateNode < ::Prism::Node
+  # Initialize a new MatchPredicateNode node.
+  #
+  # @return [MatchPredicateNode] a new instance of MatchPredicateNode
+  def initialize(source, node_id, location, flags, value, pattern, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader pattern: Prism::node
+  def pattern; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `=>` operator.
+#
+#     foo => bar
+#     ^^^^^^^^^^
+class Prism::MatchRequiredNode < ::Prism::Node
+  # Initialize a new MatchRequiredNode node.
+  #
+  # @return [MatchRequiredNode] a new instance of MatchRequiredNode
+  def initialize(source, node_id, location, flags, value, pattern, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchRequiredNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # attr_reader pattern: Prism::node
+  def pattern; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents writing local variables using a regular expression match with named capture groups.
+#
+#     /(?<foo>bar)/ =~ baz
+#     ^^^^^^^^^^^^^^^^^^^^
+class Prism::MatchWriteNode < ::Prism::Node
+  # Initialize a new MatchWriteNode node.
+  #
+  # @return [MatchWriteNode] a new instance of MatchWriteNode
+  def initialize(source, node_id, location, flags, call, targets); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader call: CallNode
+  def call; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?call: CallNode, ?targets: Array[LocalVariableTargetNode]) -> MatchWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), call: T.unsafe(nil), targets: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader targets: Array[LocalVariableTargetNode]
+  def targets; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a node that is missing from the source and results in a syntax error.
+class Prism::MissingNode < ::Prism::Node
+  # Initialize a new MissingNode node.
+  #
+  # @return [MissingNode] a new instance of MissingNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> MissingNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a module declaration involving the `module` keyword.
+#
+#     module Foo end
+#     ^^^^^^^^^^^^^^
+class Prism::ModuleNode < ::Prism::Node
+  # Initialize a new ModuleNode node.
+  #
+  # @return [ModuleNode] a new instance of ModuleNode
+  def initialize(source, node_id, location, flags, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader constant_path: Prism::node
+  def constant_path; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: Prism::node, body: Prism::node?, end_keyword_loc: Location, name: Symbol }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # def module_keyword: () -> String
+  def module_keyword; end
+
+  # attr_reader module_keyword_loc: Location
+  def module_keyword_loc; end
+
+  # attr_reader name: Symbol
+  def name; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a multi-target expression.
+#
+#     a, (b, c) = 1, 2, 3
+#        ^^^^^^
+#
+# This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
+#
+#     for a, b in [[1, 2], [3, 4]]
+#         ^^^^
+class Prism::MultiTargetNode < ::Prism::Node
+  # Initialize a new MultiTargetNode node.
+  #
+  # @return [MultiTargetNode] a new instance of MultiTargetNode
+  def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the targets expressions before a splat node.
+  #
+  #     a, (b, c, *) = 1, 2, 3, 4, 5
+  #         ^^^^
+  #
+  # The splat node can be absent, in that case all target expressions are in the left field.
+  #
+  #     a, (b, c) = 1, 2, 3, 4, 5
+  #         ^^^^
+  def lefts; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # The location of the opening parenthesis.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #        ^
+  def lparen_loc; end
+
+  # Represents a splat node in the target expression.
+  #
+  #     a, (b, *c) = 1, 2, 3, 4
+  #            ^^
+  #
+  # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+  #
+  #     a, (b, *) = 1, 2, 3, 4
+  #            ^
+  #
+  # If the `*` is omitted, the field will containt an `ImplicitRestNode`
+  #
+  #     a, (b,) = 1, 2, 3, 4
+  #          ^
+  def rest; end
+
+  # Represents the targets expressions after a splat node.
+  #
+  #     a, (*, b, c) = 1, 2, 3, 4, 5
+  #            ^^^^
+  def rights; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # The location of the closing parenthesis.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #             ^
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a write to a multi-target expression.
+#
+#     a, b, c = 1, 2, 3
+#     ^^^^^^^^^^^^^^^^^
+class Prism::MultiWriteNode < ::Prism::Node
+  # Initialize a new MultiWriteNode node.
+  #
+  # @return [MultiWriteNode] a new instance of MultiWriteNode
+  def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Represents the targets expressions before a splat node.
+  #
+  #     a, b, * = 1, 2, 3, 4, 5
+  #     ^^^^
+  #
+  # The splat node can be absent, in that case all target expressions are in the left field.
+  #
+  #     a, b, c = 1, 2, 3, 4, 5
+  #     ^^^^^^^
+  def lefts; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # The location of the opening parenthesis.
+  #
+  #     (a, b, c) = 1, 2, 3
+  #     ^
+  def lparen_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the operator.
+  #
+  #     a, b, c = 1, 2, 3
+  #             ^
+  def operator_loc; end
+
+  # Represents a splat node in the target expression.
+  #
+  #     a, b, *c = 1, 2, 3, 4
+  #           ^^
+  #
+  # The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
+  #
+  #     a, b, * = 1, 2, 3, 4
+  #           ^
+  #
+  # If the `*` is omitted, the field will containt an `ImplicitRestNode`
+  #
+  #     a, b, = 1, 2, 3, 4
+  #         ^
+  def rest; end
+
+  # Represents the targets expressions after a splat node.
+  #
+  #     a, *, b, c = 1, 2, 3, 4, 5
+  #           ^^^^
+  def rights; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # The location of the closing parenthesis.
+  #
+  #     (a, b, c) = 1, 2, 3
+  #             ^
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     a, b, c = 1, 2, 3
+  #               ^^^^^^^
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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.
+class Prism::MutationCompiler < ::Prism::Compiler
+  # Copy a AliasGlobalVariableNode node
+  def visit_alias_global_variable_node(node); end
+
+  # Copy a AliasMethodNode node
+  def visit_alias_method_node(node); end
+
+  # Copy a AlternationPatternNode node
+  def visit_alternation_pattern_node(node); end
+
+  # Copy a AndNode node
+  def visit_and_node(node); end
+
+  # Copy a ArgumentsNode node
+  def visit_arguments_node(node); end
+
+  # Copy a ArrayNode node
+  def visit_array_node(node); end
+
+  # Copy a ArrayPatternNode node
+  def visit_array_pattern_node(node); end
+
+  # Copy a AssocNode node
+  def visit_assoc_node(node); end
+
+  # Copy a AssocSplatNode node
+  def visit_assoc_splat_node(node); end
+
+  # Copy a BackReferenceReadNode node
+  def visit_back_reference_read_node(node); end
+
+  # Copy a BeginNode node
+  def visit_begin_node(node); end
+
+  # Copy a BlockArgumentNode node
+  def visit_block_argument_node(node); end
+
+  # Copy a BlockLocalVariableNode node
+  def visit_block_local_variable_node(node); end
+
+  # Copy a BlockNode node
+  def visit_block_node(node); end
+
+  # Copy a BlockParameterNode node
+  def visit_block_parameter_node(node); end
+
+  # Copy a BlockParametersNode node
+  def visit_block_parameters_node(node); end
+
+  # Copy a BreakNode node
+  def visit_break_node(node); end
+
+  # Copy a CallAndWriteNode node
+  def visit_call_and_write_node(node); end
+
+  # Copy a CallNode node
+  def visit_call_node(node); end
+
+  # Copy a CallOperatorWriteNode node
+  def visit_call_operator_write_node(node); end
+
+  # Copy a CallOrWriteNode node
+  def visit_call_or_write_node(node); end
+
+  # Copy a CallTargetNode node
+  def visit_call_target_node(node); end
+
+  # Copy a CapturePatternNode node
+  def visit_capture_pattern_node(node); end
+
+  # Copy a CaseMatchNode node
+  def visit_case_match_node(node); end
+
+  # Copy a CaseNode node
+  def visit_case_node(node); end
+
+  # Copy a ClassNode node
+  def visit_class_node(node); end
+
+  # Copy a ClassVariableAndWriteNode node
+  def visit_class_variable_and_write_node(node); end
+
+  # Copy a ClassVariableOperatorWriteNode node
+  def visit_class_variable_operator_write_node(node); end
+
+  # Copy a ClassVariableOrWriteNode node
+  def visit_class_variable_or_write_node(node); end
+
+  # Copy a ClassVariableReadNode node
+  def visit_class_variable_read_node(node); end
+
+  # Copy a ClassVariableTargetNode node
+  def visit_class_variable_target_node(node); end
+
+  # Copy a ClassVariableWriteNode node
+  def visit_class_variable_write_node(node); end
+
+  # Copy a ConstantAndWriteNode node
+  def visit_constant_and_write_node(node); end
+
+  # Copy a ConstantOperatorWriteNode node
+  def visit_constant_operator_write_node(node); end
+
+  # Copy a ConstantOrWriteNode node
+  def visit_constant_or_write_node(node); end
+
+  # Copy a ConstantPathAndWriteNode node
+  def visit_constant_path_and_write_node(node); end
+
+  # Copy a ConstantPathNode node
+  def visit_constant_path_node(node); end
+
+  # Copy a ConstantPathOperatorWriteNode node
+  def visit_constant_path_operator_write_node(node); end
+
+  # Copy a ConstantPathOrWriteNode node
+  def visit_constant_path_or_write_node(node); end
+
+  # Copy a ConstantPathTargetNode node
+  def visit_constant_path_target_node(node); end
+
+  # Copy a ConstantPathWriteNode node
+  def visit_constant_path_write_node(node); end
+
+  # Copy a ConstantReadNode node
+  def visit_constant_read_node(node); end
+
+  # Copy a ConstantTargetNode node
+  def visit_constant_target_node(node); end
+
+  # Copy a ConstantWriteNode node
+  def visit_constant_write_node(node); end
+
+  # Copy a DefNode node
+  def visit_def_node(node); end
+
+  # Copy a DefinedNode node
+  def visit_defined_node(node); end
+
+  # Copy a ElseNode node
+  def visit_else_node(node); end
+
+  # Copy a EmbeddedStatementsNode node
+  def visit_embedded_statements_node(node); end
+
+  # Copy a EmbeddedVariableNode node
+  def visit_embedded_variable_node(node); end
+
+  # Copy a EnsureNode node
+  def visit_ensure_node(node); end
+
+  # Copy a FalseNode node
+  def visit_false_node(node); end
+
+  # Copy a FindPatternNode node
+  def visit_find_pattern_node(node); end
+
+  # Copy a FlipFlopNode node
+  def visit_flip_flop_node(node); end
+
+  # Copy a FloatNode node
+  def visit_float_node(node); end
+
+  # Copy a ForNode node
+  def visit_for_node(node); end
+
+  # Copy a ForwardingArgumentsNode node
+  def visit_forwarding_arguments_node(node); end
+
+  # Copy a ForwardingParameterNode node
+  def visit_forwarding_parameter_node(node); end
+
+  # Copy a ForwardingSuperNode node
+  def visit_forwarding_super_node(node); end
+
+  # Copy a GlobalVariableAndWriteNode node
+  def visit_global_variable_and_write_node(node); end
+
+  # Copy a GlobalVariableOperatorWriteNode node
+  def visit_global_variable_operator_write_node(node); end
+
+  # Copy a GlobalVariableOrWriteNode node
+  def visit_global_variable_or_write_node(node); end
+
+  # Copy a GlobalVariableReadNode node
+  def visit_global_variable_read_node(node); end
+
+  # Copy a GlobalVariableTargetNode node
+  def visit_global_variable_target_node(node); end
+
+  # Copy a GlobalVariableWriteNode node
+  def visit_global_variable_write_node(node); end
+
+  # Copy a HashNode node
+  def visit_hash_node(node); end
+
+  # Copy a HashPatternNode node
+  def visit_hash_pattern_node(node); end
+
+  # Copy a IfNode node
+  def visit_if_node(node); end
+
+  # Copy a ImaginaryNode node
+  def visit_imaginary_node(node); end
+
+  # Copy a ImplicitNode node
+  def visit_implicit_node(node); end
+
+  # Copy a ImplicitRestNode node
+  def visit_implicit_rest_node(node); end
+
+  # Copy a InNode node
+  def visit_in_node(node); end
+
+  # Copy a IndexAndWriteNode node
+  def visit_index_and_write_node(node); end
+
+  # Copy a IndexOperatorWriteNode node
+  def visit_index_operator_write_node(node); end
+
+  # Copy a IndexOrWriteNode node
+  def visit_index_or_write_node(node); end
+
+  # Copy a IndexTargetNode node
+  def visit_index_target_node(node); end
+
+  # Copy a InstanceVariableAndWriteNode node
+  def visit_instance_variable_and_write_node(node); end
+
+  # Copy a InstanceVariableOperatorWriteNode node
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Copy a InstanceVariableOrWriteNode node
+  def visit_instance_variable_or_write_node(node); end
+
+  # Copy a InstanceVariableReadNode node
+  def visit_instance_variable_read_node(node); end
+
+  # Copy a InstanceVariableTargetNode node
+  def visit_instance_variable_target_node(node); end
+
+  # Copy a InstanceVariableWriteNode node
+  def visit_instance_variable_write_node(node); end
+
+  # Copy a IntegerNode node
+  def visit_integer_node(node); end
+
+  # Copy a InterpolatedMatchLastLineNode node
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Copy a InterpolatedRegularExpressionNode node
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Copy a InterpolatedStringNode node
+  def visit_interpolated_string_node(node); end
+
+  # Copy a InterpolatedSymbolNode node
+  def visit_interpolated_symbol_node(node); end
+
+  # Copy a InterpolatedXStringNode node
+  def visit_interpolated_x_string_node(node); end
+
+  # Copy a ItLocalVariableReadNode node
+  def visit_it_local_variable_read_node(node); end
+
+  # Copy a ItParametersNode node
+  def visit_it_parameters_node(node); end
+
+  # Copy a KeywordHashNode node
+  def visit_keyword_hash_node(node); end
+
+  # Copy a KeywordRestParameterNode node
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Copy a LambdaNode node
+  def visit_lambda_node(node); end
+
+  # Copy a LocalVariableAndWriteNode node
+  def visit_local_variable_and_write_node(node); end
+
+  # Copy a LocalVariableOperatorWriteNode node
+  def visit_local_variable_operator_write_node(node); end
+
+  # Copy a LocalVariableOrWriteNode node
+  def visit_local_variable_or_write_node(node); end
+
+  # Copy a LocalVariableReadNode node
+  def visit_local_variable_read_node(node); end
+
+  # Copy a LocalVariableTargetNode node
+  def visit_local_variable_target_node(node); end
+
+  # Copy a LocalVariableWriteNode node
+  def visit_local_variable_write_node(node); end
+
+  # Copy a MatchLastLineNode node
+  def visit_match_last_line_node(node); end
+
+  # Copy a MatchPredicateNode node
+  def visit_match_predicate_node(node); end
+
+  # Copy a MatchRequiredNode node
+  def visit_match_required_node(node); end
+
+  # Copy a MatchWriteNode node
+  def visit_match_write_node(node); end
+
+  # Copy a MissingNode node
+  def visit_missing_node(node); end
+
+  # Copy a ModuleNode node
+  def visit_module_node(node); end
+
+  # Copy a MultiTargetNode node
+  def visit_multi_target_node(node); end
+
+  # Copy a MultiWriteNode node
+  def visit_multi_write_node(node); end
+
+  # Copy a NextNode node
+  def visit_next_node(node); end
+
+  # Copy a NilNode node
+  def visit_nil_node(node); end
+
+  # Copy a NoKeywordsParameterNode node
+  def visit_no_keywords_parameter_node(node); end
+
+  # Copy a NumberedParametersNode node
+  def visit_numbered_parameters_node(node); end
+
+  # Copy a NumberedReferenceReadNode node
+  def visit_numbered_reference_read_node(node); end
+
+  # Copy a OptionalKeywordParameterNode node
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Copy a OptionalParameterNode node
+  def visit_optional_parameter_node(node); end
+
+  # Copy a OrNode node
+  def visit_or_node(node); end
+
+  # Copy a ParametersNode node
+  def visit_parameters_node(node); end
+
+  # Copy a ParenthesesNode node
+  def visit_parentheses_node(node); end
+
+  # Copy a PinnedExpressionNode node
+  def visit_pinned_expression_node(node); end
+
+  # Copy a PinnedVariableNode node
+  def visit_pinned_variable_node(node); end
+
+  # Copy a PostExecutionNode node
+  def visit_post_execution_node(node); end
+
+  # Copy a PreExecutionNode node
+  def visit_pre_execution_node(node); end
+
+  # Copy a ProgramNode node
+  def visit_program_node(node); end
+
+  # Copy a RangeNode node
+  def visit_range_node(node); end
+
+  # Copy a RationalNode node
+  def visit_rational_node(node); end
+
+  # Copy a RedoNode node
+  def visit_redo_node(node); end
+
+  # Copy a RegularExpressionNode node
+  def visit_regular_expression_node(node); end
+
+  # Copy a RequiredKeywordParameterNode node
+  def visit_required_keyword_parameter_node(node); end
+
+  # Copy a RequiredParameterNode node
+  def visit_required_parameter_node(node); end
+
+  # Copy a RescueModifierNode node
+  def visit_rescue_modifier_node(node); end
+
+  # Copy a RescueNode node
+  def visit_rescue_node(node); end
+
+  # Copy a RestParameterNode node
+  def visit_rest_parameter_node(node); end
+
+  # Copy a RetryNode node
+  def visit_retry_node(node); end
+
+  # Copy a ReturnNode node
+  def visit_return_node(node); end
+
+  # Copy a SelfNode node
+  def visit_self_node(node); end
+
+  # Copy a ShareableConstantNode node
+  def visit_shareable_constant_node(node); end
+
+  # Copy a SingletonClassNode node
+  def visit_singleton_class_node(node); end
+
+  # Copy a SourceEncodingNode node
+  def visit_source_encoding_node(node); end
+
+  # Copy a SourceFileNode node
+  def visit_source_file_node(node); end
+
+  # Copy a SourceLineNode node
+  def visit_source_line_node(node); end
+
+  # Copy a SplatNode node
+  def visit_splat_node(node); end
+
+  # Copy a StatementsNode node
+  def visit_statements_node(node); end
+
+  # Copy a StringNode node
+  def visit_string_node(node); end
+
+  # Copy a SuperNode node
+  def visit_super_node(node); end
+
+  # Copy a SymbolNode node
+  def visit_symbol_node(node); end
+
+  # Copy a TrueNode node
+  def visit_true_node(node); end
+
+  # Copy a UndefNode node
+  def visit_undef_node(node); end
+
+  # Copy a UnlessNode node
+  def visit_unless_node(node); end
+
+  # Copy a UntilNode node
+  def visit_until_node(node); end
+
+  # Copy a WhenNode node
+  def visit_when_node(node); end
+
+  # Copy a WhileNode node
+  def visit_while_node(node); end
+
+  # Copy a XStringNode node
+  def visit_x_string_node(node); end
+
+  # Copy a YieldNode node
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `next` keyword.
+#
+#     next 1
+#     ^^^^^^
+class Prism::NextNode < ::Prism::Node
+  # Initialize a new NextNode node.
+  #
+  # @return [NextNode] a new instance of NextNode
+  def initialize(source, node_id, location, flags, arguments, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> NextNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `nil` keyword.
+#
+#     nil
+#     ^^^
+class Prism::NilNode < ::Prism::Node
+  # Initialize a new NilNode node.
+  #
+  # @return [NilNode] a new instance of NilNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> NilNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of `**nil` inside method arguments.
+#
+#     def a(**nil)
+#           ^^^^^
+#     end
+class Prism::NoKeywordsParameterNode < ::Prism::Node
+  # Initialize a new NoKeywordsParameterNode node.
+  #
+  # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode
+  def initialize(source, node_id, location, flags, operator_loc, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?keyword_loc: Location) -> NoKeywordsParameterNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents a node in the tree. It is the parent class of all of the
+# various node types.
+class Prism::Node
+  abstract!
+
+  # Accepts a visitor and calls back into the specialized visit function.
+  #
+  # @raise [NoMethodError]
+  sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # Returns the first node that matches the given block when visited in a
+  # depth-first search. This is useful for finding a node that matches a
+  # particular condition.
+  #
+  #     node.breadth_first_search { |node| node.node_id == node_id }
+  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
+  def breadth_first_search(&block); end
+
+  # Returns an array of child nodes, including `nil`s in the place of optional
+  # nodes that were not present.
+  #
+  # @raise [NoMethodError]
+  sig { abstract.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]
+  sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  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]
+  sig { abstract.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]
+  sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  def deprecated(*replacements); end
+
+  # The end offset of the node in the source. This method is effectively a
+  # delegate method to the location object.
+  sig { returns(Integer) }
+  def end_offset; end
+
+  sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Returns a string representation of the node.
+  #
+  # @raise [NoMethodError]
+  sig { abstract.returns(String) }
+  def inspect; end
+
+  # A Location instance that represents the location of this node in the
+  # source.
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Returns true if the node has the newline flag set.
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def newline?; end
+
+  def newline_flag!(lines); end
+
+  # @return [Boolean]
+  def newline_flag?; end
+
+  # A unique identifier for this node. This is used in a very specific
+  # use case where you want to keep around a reference to a node without
+  # having to keep around the syntax tree in memory. This unique identifier
+  # will be consistent across multiple parses of the same source code.
+  sig { returns(Integer) }
+  def node_id; end
+
+  # Similar to inspect, but respects the current level of indentation given by
+  # the pretty print object.
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # Returns all of the lines of the source code associated with this node.
+  # An alias for source_lines, used to mimic the API from
+  # RubyVM::AbstractSyntaxTree to make it easier to migrate.
+  sig { returns(T::Array[String]) }
+  def script_lines; end
+
+  # Slice the location of the node from the source.
+  sig { returns(String) }
+  def slice; end
+
+  # Slice the location of the node from the source, starting at the beginning
+  # of the line that the location starts on, ending at the end of the line
+  # that the location ends on.
+  sig { returns(String) }
+  def slice_lines; end
+
+  # Returns all of the lines of the source code associated with this node.
+  sig { returns(T::Array[String]) }
+  def source_lines; end
+
+  # The start offset of the node in the source. This method is effectively a
+  # delegate method to the location object.
+  sig { returns(Integer) }
+  def start_offset; end
+
+  # Returns true if the node has the static literal flag set.
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def static_literal?; end
+
+  # Convert this node into a graphviz dot graph string.
+  sig { returns(String) }
+  def to_dot; end
+
+  # Returns a list of nodes that are descendants of this node that contain the
+  # given line and column. This is useful for locating a node that is selected
+  # based on the line and column of the source code.
+  #
+  # Important to note is that the column given to this method should be in
+  # bytes, as opposed to characters or code units.
+  sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
+  def tunnel(line, column); 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.
+  #
+  # @raise [NoMethodError]
+  sig { abstract.returns(Symbol) }
+  def type; end
+
+  protected
+
+  # An bitset of flags for this node. There are certain flags that are common
+  # for all nodes, and then some nodes have specific flags.
+  sig { returns(Integer) }
+  def flags; end
+
+  private
+
+  # A pointer to the source that this node was created from.
+  sig { returns(Prism::Source) }
+  def source; end
+
+  class << self
+    # Returns a list of the fields that exist for this node class. Fields
+    # describe the structure of the node. This kind of reflection is useful for
+    # things like recursively visiting each node _and_ field in the tree.
+    #
+    # @raise [NoMethodError]
+    def fields; end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # @raise [NoMethodError]
+    def type; end
+  end
+end
+
+# The flags that are common to all nodes.
+module Prism::NodeFlags; end
+
+# A flag to indicate that the node is a candidate to emit a :line event
+# through tracepoint when compiled.
+Prism::NodeFlags::NEWLINE = T.let(T.unsafe(nil), Integer)
+
+# A flag to indicate that the value that the node represents is a value that
+# can be determined at parse-time.
+Prism::NodeFlags::STATIC_LITERAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
+#
+#     -> { _1 + _2 }
+#     ^^^^^^^^^^^^^^
+class Prism::NumberedParametersNode < ::Prism::Node
+  # Initialize a new NumberedParametersNode node.
+  #
+  # @return [NumberedParametersNode] a new instance of NumberedParametersNode
+  def initialize(source, node_id, location, flags, maximum); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?maximum: Integer) -> NumberedParametersNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), maximum: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader maximum: Integer
+  def maximum; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents reading a numbered reference to a capture in the previous match.
+#
+#     $1
+#     ^^
+class Prism::NumberedReferenceReadNode < ::Prism::Node
+  # Initialize a new NumberedReferenceReadNode node.
+  #
+  # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
+  def initialize(source, node_id, location, flags, number); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?number: Integer) -> NumberedReferenceReadNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), number: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
+  #
+  #     $1          # number `1`
+  #
+  #     $5432       # number `5432`
+  #
+  #     $4294967296 # number `0`
+  def number; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an optional keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: 1)
+#           ^^^^
+#     end
+class Prism::OptionalKeywordParameterNode < ::Prism::Node
+  # Initialize a new OptionalKeywordParameterNode node.
+  #
+  # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node) -> OptionalKeywordParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalKeywordParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an optional parameter to a method, block, or lambda definition.
+#
+#     def a(b = 1)
+#           ^^^^^
+#     end
+class Prism::OptionalParameterNode < ::Prism::Node
+  # Initialize a new OptionalParameterNode node.
+  #
+  # @return [OptionalParameterNode] a new instance of OptionalParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> OptionalParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location,
+      operator_loc: Prism::Location,
+      value: Prism::Node
+    ).returns(Prism::OptionalParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader value: Prism::node
+  sig { returns(Prism::Node) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `||` operator or the `or` keyword.
+#
+#     left or right
+#     ^^^^^^^^^^^^^
+class Prism::OrNode < ::Prism::Node
+  # Initialize a new OrNode node.
+  #
+  # @return [OrNode] a new instance of OrNode
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> OrNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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
+  #     ^
+  def left; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # The location of the `or` keyword or the `||` operator.
+  #
+  #     left or right
+  #          ^^
+  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
+  #          ^
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# A parser for the pack template language.
+module Prism::Pack
+  class << self
+    def parse(_arg0, _arg1, _arg2); end
+  end
+end
+
+Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
+
+# A directive in the pack template language.
+class Prism::Pack::Directive
+  # Initialize a new directive with the given values.
+  #
+  # @return [Directive] a new instance of Directive
+  def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
+
+  # Provide a human-readable description of the directive.
+  def describe; end
+
+  # The type of endianness of the directive.
+  def endian; end
+
+  # The length of this directive (used for integers).
+  def length; end
+
+  # The length type of this directive (used for integers).
+  def length_type; end
+
+  # The type of signedness of the directive.
+  def signed; end
+
+  # The size of the directive.
+  def size; end
+
+  # A byteslice of the source string that this directive represents.
+  def source; end
+
+  # The type of the directive.
+  def type; end
+
+  # A symbol representing whether or not we are packing or unpacking.
+  def variant; end
+
+  # A symbol representing the version of Ruby.
+  def version; end
+end
+
+# The descriptions of the various types of endianness.
+Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of signedness.
+Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of sizes.
+Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
+
+# The result of parsing a pack template.
+class Prism::Pack::Format
+  # Create a new Format with the given directives and encoding.
+  #
+  # @return [Format] a new instance of Format
+  def initialize(directives, encoding); end
+
+  # Provide a human-readable description of the format.
+  def describe; end
+
+  # A list of the directives in the template.
+  def directives; end
+
+  # The encoding of the template.
+  def encoding; end
+end
+
+Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
+Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
+
+# Flags for parameter nodes.
+module Prism::ParameterFlags; end
+
+# a parameter name that has been repeated in the method signature
+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
+class Prism::ParametersNode < ::Prism::Node
+  # Initialize a new ParametersNode node.
+  #
+  # @return [ParametersNode] a new instance of ParametersNode
+  def initialize(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader block: BlockParameterNode?
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
+  def keyword_rest; end
+
+  # attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
+  def keywords; end
+
+  # attr_reader optionals: Array[OptionalParameterNode]
+  def optionals; end
+
+  # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
+  def posts; end
+
+  # attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
+  def requireds; end
+
+  # attr_reader rest: RestParameterNode | ImplicitRestNode | nil
+  def rest; end
+
+  # Mirrors the Method#parameters method.
+  sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
+  def signature; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a parenthesized expression
+#
+#     (10 + 34)
+#     ^^^^^^^^^
+class Prism::ParenthesesNode < ::Prism::Node
+  # Initialize a new ParenthesesNode node.
+  #
+  # @return [ParenthesesNode] a new instance of ParenthesesNode
+  def initialize(source, node_id, location, flags, body, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location) -> ParenthesesNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  def newline_flag!(lines); end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents an error that was encountered during parsing.
+class Prism::ParseError
+  # Create a new error object with the given message and location.
+  #
+  # @return [ParseError] a new instance of ParseError
+  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
+  def initialize(type, message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseError.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this error.
+  sig { returns(String) }
+  def inspect; end
+
+  # The level of this error.
+  sig { returns(Symbol) }
+  def level; end
+
+  # A Location object representing the location of this error in the source.
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this error.
+  sig { returns(String) }
+  def message; end
+
+  # The type of error. This is an _internal_ symbol that is used for
+  # communicating with translation layers. It is not meant to be public API.
+  sig { returns(Symbol) }
+  def type; end
+end
+
+# This is a result specific to the `parse_lex` and `parse_lex_file` methods.
+class Prism::ParseLexResult < ::Prism::Result
+  # Create a new parse lex result object with the given values.
+  #
+  # @return [ParseLexResult] a new instance of ParseLexResult
+  sig do
+    params(
+      value: [Prism::ProgramNode, T::Array[T.untyped]],
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Implement the hash pattern matching interface for ParseLexResult.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # A tuple of the syntax tree and the list of tokens that were parsed from
+  # the source code.
+  sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
+  def value; end
+end
+
+# This is a result specific to the `parse` and `parse_file` methods.
+class Prism::ParseResult < ::Prism::Result
+  # Create a new parse result object with the given values.
+  #
+  # @return [ParseResult] a new instance of ParseResult
+  sig do
+    params(
+      value: Prism::ProgramNode,
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # Attach the list of comments to their respective locations in the tree.
+  def attach_comments!; end
+
+  # Implement the hash pattern matching interface for ParseResult.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of the syntax tree with the errors
+  # displayed inline.
+  def errors_format; end
+
+  # Walk the tree and mark nodes that are on a new line, loosely emulating
+  # the behavior of CRuby's `:line` tracepoint event.
+  def mark_newlines!; end
+
+  # The syntax tree that was parsed from the source code.
+  sig { returns(Prism::ProgramNode) }
+  def value; 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.
+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
+  def initialize(parse_result); end
+
+  # Attach the comments to their respective locations in the tree by
+  # mutating the parse result.
+  def attach!; end
+
+  # The parse result that we are attaching comments to.
+  def parse_result; end
+
+  private
+
+  # Responsible for finding the nearest targets to the given comment within
+  # the context of the given encapsulating node.
+  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.
+class Prism::ParseResult::Comments::LocationTarget
+  # @return [LocationTarget] a new instance of LocationTarget
+  def initialize(location); end
+
+  # @return [Boolean]
+  def encloses?(comment); end
+
+  def end_offset; end
+  def leading_comment(comment); end
+  def location; end
+  def start_offset; end
+  def trailing_comment(comment); end
+end
+
+# A target for attaching comments that is based on a specific node's
+# location.
+class Prism::ParseResult::Comments::NodeTarget
+  # @return [NodeTarget] a new instance of NodeTarget
+  def initialize(node); end
+
+  # @return [Boolean]
+  def encloses?(comment); end
+
+  def end_offset; end
+  def leading_comment(comment); end
+  def node; end
+  def start_offset; end
+  def trailing_comment(comment); end
+end
+
+# An object to represent the set of errors on a parse result. This object
+# can be used to format the errors in a human-readable way.
+class Prism::ParseResult::Errors
+  # Initialize a new set of errors from the given parse result.
+  #
+  # @return [Errors] a new instance of Errors
+  def initialize(parse_result); end
+
+  # Formats the errors in a human-readable way and return them as a string.
+  def format; end
+
+  # The parse result that contains the errors.
+  def parse_result; 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.
+#
+# This file is autoloaded only when `mark_newlines!` is called, so the
+# re-opening of the various nodes in this file will only be performed in
+# that case. We do that to avoid storing the extra `@newline` instance
+# variable on every node if we don't need it.
+class Prism::ParseResult::Newlines < ::Prism::Visitor
+  # Create a new Newlines visitor with the given newline offsets.
+  #
+  # @return [Newlines] a new instance of Newlines
+  def initialize(lines); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  def visit_block_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  def visit_if_node(node); end
+
+  # Permit block/lambda nodes to mark newlines within themselves.
+  def visit_lambda_node(node); end
+
+  # Permit statements lists to mark newlines within themselves.
+  def visit_statements_node(node); end
+
+  # Mark if/unless nodes as newlines.
+  def visit_unless_node(node); end
+end
+
+# This represents a warning that was encountered during parsing.
+class Prism::ParseWarning
+  # Create a new warning object with the given message and location.
+  #
+  # @return [ParseWarning] a new instance of ParseWarning
+  sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
+  def initialize(type, message, location, level); end
+
+  # Implement the hash pattern matching interface for ParseWarning.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this warning.
+  sig { returns(String) }
+  def inspect; end
+
+  # The level of this warning.
+  sig { returns(Symbol) }
+  def level; end
+
+  # A Location object representing the location of this warning in the source.
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # The message associated with this warning.
+  sig { returns(String) }
+  def message; end
+
+  # The type of warning. This is an _internal_ symbol that is used for
+  # communicating with translation layers. It is not meant to be public API.
+  sig { returns(Symbol) }
+  def type; 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.
+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
+  def initialize(query); end
+
+  # Compile the query into a callable object that can be used to match against
+  # nodes.
+  #
+  # @raise [CompilationError]
+  def compile; end
+
+  # The query that this pattern was initialized with.
+  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.
+  def scan(root); end
+
+  private
+
+  # Shortcut for combining two procs into one that returns true if both return
+  # true.
+  def combine_and(left, right); end
+
+  # Shortcut for combining two procs into one that returns true if either
+  # returns true.
+  def combine_or(left, right); end
+
+  # in foo | bar
+  def compile_alternation_pattern_node(node); end
+
+  # in [foo, bar, baz]
+  def compile_array_pattern_node(node); end
+
+  # Compile a name associated with a constant.
+  def compile_constant_name(node, name); end
+
+  # in Prism::ConstantReadNode
+  def compile_constant_path_node(node); end
+
+  # in ConstantReadNode
+  # in String
+  def compile_constant_read_node(node); end
+
+  # Raise an error because the given node is not supported.
+  #
+  # @raise [CompilationError]
+  def compile_error(node); end
+
+  # in InstanceVariableReadNode[name: Symbol]
+  # in { name: Symbol }
+  def compile_hash_pattern_node(node); end
+
+  # in nil
+  def compile_nil_node(node); end
+
+  # Compile any kind of node. Dispatch out to the individual compilation
+  # methods based on the type of node.
+  def compile_node(node); end
+
+  # in /foo/
+  def compile_regular_expression_node(node); end
+
+  # in ""
+  # in "foo"
+  def compile_string_node(node); end
+
+  # in :+
+  # in :foo
+  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.
+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
+  def initialize(repr); end
+end
+
+# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
+#
+#     foo in ^(bar)
+#            ^^^^^^
+class Prism::PinnedExpressionNode < ::Prism::Node
+  # Initialize a new PinnedExpressionNode node.
+  #
+  # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
+  def initialize(source, node_id, location, flags, expression, operator_loc, lparen_loc, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location) -> PinnedExpressionNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def lparen: () -> String
+  def lparen; end
+
+  # attr_reader lparen_loc: Location
+  def lparen_loc; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # def rparen: () -> String
+  def rparen; end
+
+  # attr_reader rparen_loc: Location
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
+#
+#     foo in ^bar
+#            ^^^^
+class Prism::PinnedVariableNode < ::Prism::Node
+  # Initialize a new PinnedVariableNode node.
+  #
+  # @return [PinnedVariableNode] a new instance of PinnedVariableNode
+  def initialize(source, node_id, location, flags, variable, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: Prism::node, ?operator_loc: Location) -> PinnedVariableNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: Prism::node, operator_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader variable: Prism::node
+  def variable; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `END` keyword.
+#
+#     END { foo }
+#     ^^^^^^^^^^^
+class Prism::PostExecutionNode < ::Prism::Node
+  # Initialize a new PostExecutionNode node.
+  #
+  # @return [PostExecutionNode] a new instance of PostExecutionNode
+  def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PostExecutionNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `BEGIN` keyword.
+#
+#     BEGIN { foo }
+#     ^^^^^^^^^^^^^
+class Prism::PreExecutionNode < ::Prism::Node
+  # Initialize a new PreExecutionNode node.
+  #
+  # @return [PreExecutionNode] a new instance of PreExecutionNode
+  def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def closing: () -> String
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PreExecutionNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def opening: () -> String
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  def opening_loc; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# The top level node of any parse tree.
+class Prism::ProgramNode < ::Prism::Node
+  # Initialize a new ProgramNode node.
+  #
+  # @return [ProgramNode] a new instance of ProgramNode
+  def initialize(source, node_id, location, flags, locals, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?statements: StatementsNode) -> ProgramNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # attr_reader statements: StatementsNode
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for range and flip-flop nodes.
+module Prism::RangeFlags; end
+
+# ... operator
+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/
+#          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+class Prism::RangeNode < ::Prism::Node
+  # Initialize a new RangeNode node.
+  #
+  # @return [RangeNode] a new instance of RangeNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, left, right, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> RangeNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      left: T.nilable(Prism::Node),
+      right: T.nilable(Prism::Node),
+      operator_loc: Prism::Location
+    ).returns(Prism::RangeNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def exclude_end?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def exclude_end?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; 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
+  #     ^^^^^
+  sig { returns(T.nilable(Prism::Node)) }
+  def left; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # The location of the `..` or `...` operator.
+  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.
+  sig { returns(T.nilable(Prism::Node)) }
+  def right; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a rational number literal.
+#
+#     1.0r
+#     ^^^^
+class Prism::RationalNode < ::Prism::Node
+  # Initialize a new RationalNode node.
+  #
+  # @return [RationalNode] a new instance of RationalNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).void
+  end
+  def initialize(source, node_id, location, flags, numerator, denominator); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def binary?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def binary?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numerator: Integer, ?denominator: Integer) -> RationalNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      numerator: Integer,
+      denominator: Integer
+    ).returns(Prism::RationalNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil)); end
+
+  # def decimal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def decimal?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # The denominator of the rational number.
+  #
+  #     1.5r # denominator 2
+  sig { returns(Integer) }
+  def denominator; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def hexadecimal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def hexadecimal?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # The numerator of the rational number.
+  #
+  #     1.5r # numerator 3
+  sig { returns(Integer) }
+  def numerator; end
+
+  # Returns the value of the node as an IntegerNode or a FloatNode. This
+  # method is deprecated in favor of #value or #numerator/#denominator.
+  def numeric; end
+
+  # def octal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def octal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # Returns the value of the node as a Ruby Rational.
+  sig { returns(Rational) }
+  def value; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `redo` keyword.
+#
+#     redo
+#     ^^^^
+class Prism::RedoNode < ::Prism::Node
+  # Initialize a new RedoNode node.
+  #
+  # @return [RedoNode] a new instance of RedoNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RedoNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# The Reflection module provides the ability to reflect on the structure of
+# the syntax tree itself, as opposed to looking at a single syntax tree. This
+# is useful in metaprogramming contexts.
+module Prism::Reflection
+  class << self
+    # Returns the fields for the given node.
+    sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
+    def fields_for(node); end
+  end
+end
+
+# A constant field represents a constant value on a node. Effectively, it
+# represents an identifier found within the source. It resolves to a symbol
+# in Ruby.
+class Prism::Reflection::ConstantField < ::Prism::Reflection::Field; end
+
+# A constant list field represents a list of constant values on a node. It
+# resolves to an array of symbols in Ruby.
+class Prism::Reflection::ConstantListField < ::Prism::Reflection::Field; end
+
+# A field represents a single piece of data on a node. It is the base class
+# for all other field types.
+class Prism::Reflection::Field
+  # Initializes the field with the given name.
+  #
+  # @return [Field] a new instance of Field
+  sig { params(name: Symbol).void }
+  def initialize(name); end
+
+  # The name of the field.
+  sig { returns(Symbol) }
+  def name; end
+end
+
+# A flags field represents a bitset of flags on a node. It resolves to an
+# integer in Ruby. Note that the flags cannot be accessed directly on the
+# node because the integer is kept private. Instead, the various flags in
+# the bitset should be accessed through their query methods.
+class Prism::Reflection::FlagsField < ::Prism::Reflection::Field
+  # Initializes the flags field with the given name and flags.
+  #
+  # @return [FlagsField] a new instance of FlagsField
+  sig { params(name: Symbol, flags: T::Array[Symbol]).void }
+  def initialize(name, flags); end
+
+  # The names of the flags in the bitset.
+  sig { returns(T::Array[Symbol]) }
+  def flags; end
+end
+
+# A float field represents a double-precision floating point value. It is
+# used exclusively to represent the value of a floating point literal. It
+# resolves to a Float in Ruby.
+class Prism::Reflection::FloatField < ::Prism::Reflection::Field; end
+
+# An integer field represents an integer value. It is used to represent the
+# value of an integer literal, the depth of local variables, and the number
+# of a numbered reference. It resolves to an Integer in Ruby.
+class Prism::Reflection::IntegerField < ::Prism::Reflection::Field; end
+
+# A location field represents the location of some part of the node in the
+# source code. For example, the location of a keyword or an operator. It
+# resolves to a Prism::Location in Ruby.
+class Prism::Reflection::LocationField < ::Prism::Reflection::Field; end
+
+# A node field represents a single child node in the syntax tree. It
+# resolves to a Prism::Node in Ruby.
+class Prism::Reflection::NodeField < ::Prism::Reflection::Field; end
+
+# A node list field represents a list of child nodes in the syntax tree. It
+# resolves to an array of Prism::Node instances in Ruby.
+class Prism::Reflection::NodeListField < ::Prism::Reflection::Field; end
+
+# An optional constant field represents a constant value on a node that may
+# or may not be present. It resolves to either a symbol or nil in Ruby.
+class Prism::Reflection::OptionalConstantField < ::Prism::Reflection::Field; end
+
+# An optional location field represents the location of some part of the
+# node in the source code that may or may not be present. It resolves to
+# either a Prism::Location or nil in Ruby.
+class Prism::Reflection::OptionalLocationField < ::Prism::Reflection::Field; end
+
+# An optional node field represents a single child node in the syntax tree
+# that may or may not be present. It resolves to either a Prism::Node or nil
+# in Ruby.
+class Prism::Reflection::OptionalNodeField < ::Prism::Reflection::Field; end
+
+# A string field represents a string value on a node. It almost always
+# represents the unescaped value of a string-like literal. It resolves to a
+# string in Ruby.
+class Prism::Reflection::StringField < ::Prism::Reflection::Field; end
+
+# Flags for regular expression and match last line nodes.
+module Prism::RegularExpressionFlags; end
+
+# n - forces the ASCII-8BIT encoding
+Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
+
+# e - forces the EUC-JP encoding
+Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer)
+
+# x - ignores whitespace and allows comments in regular expressions
+Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to binary
+Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# i - ignores the case of characters when matching
+Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer)
+
+# m - allows $ to match the end of lines within strings
+Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer)
+
+# o - only interpolates values into the regular expression once
+Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
+
+# u - forces the UTF-8 encoding
+Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
+
+# s - forces the Windows-31J encoding
+Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer)
+
+# Represents a regular expression literal with no interpolation.
+#
+#     /foo/i
+#     ^^^^^^
+class Prism::RegularExpressionNode < ::Prism::Node
+  include ::Prism::RegularExpressionOptions
+
+  # Initialize a new RegularExpressionNode node.
+  #
+  # @return [RegularExpressionNode] a new instance of RegularExpressionNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def ascii_8bit?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ascii_8bit?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::RegularExpressionNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def euc_jp?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def euc_jp?; end
+
+  # def extended?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def extended?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def ignore_case?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def ignore_case?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def multi_line?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def multi_line?; end
+
+  # def once?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def once?; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  sig { returns(Integer) }
+  def options; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  sig { returns(String) }
+  def unescaped; end
+
+  # def utf_8?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def utf_8?; end
+
+  # def windows_31j?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def windows_31j?; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+module Prism::RegularExpressionOptions
+  # Returns a numeric value that represents the flags that were used to create
+  # the regular expression.
+  def options; end
+end
+
+# Represents a required keyword parameter to a method, block, or lambda definition.
+#
+#     def a(b: )
+#           ^^
+#     end
+class Prism::RequiredKeywordParameterNode < ::Prism::Node
+  # Initialize a new RequiredKeywordParameterNode node.
+  #
+  # @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location) -> RequiredKeywordParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol,
+      name_loc: Prism::Location
+    ).returns(Prism::RequiredKeywordParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # attr_reader name_loc: Location
+  sig { returns(Prism::Location) }
+  def name_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a required parameter to a method, block, or lambda definition.
+#
+#     def a(b)
+#           ^
+#     end
+class Prism::RequiredParameterNode < ::Prism::Node
+  # Initialize a new RequiredParameterNode node.
+  #
+  # @return [RequiredParameterNode] a new instance of RequiredParameterNode
+  sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void }
+  def initialize(source, node_id, location, flags, name); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> RequiredParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: Symbol
+    ).returns(Prism::RequiredParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol
+  sig { returns(Symbol) }
+  def name; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an expression modified with a rescue.
+#
+#     foo rescue nil
+#     ^^^^^^^^^^^^^^
+class Prism::RescueModifierNode < ::Prism::Node
+  # Initialize a new RescueModifierNode node.
+  #
+  # @return [RescueModifierNode] a new instance of RescueModifierNode
+  def initialize(source, node_id, location, flags, expression, keyword_loc, rescue_expression); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node) -> RescueModifierNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  def newline_flag!(lines); end
+
+  # attr_reader rescue_expression: Prism::node
+  def rescue_expression; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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.
+class Prism::RescueNode < ::Prism::Node
+  # Initialize a new RescueNode node.
+  #
+  # @return [RescueNode] a new instance of RescueNode
+  def initialize(source, node_id, location, flags, keyword_loc, exceptions, operator_loc, reference, statements, subsequent); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # Returns the subsequent rescue clause of the rescue node. This method is
+  # deprecated in favor of #subsequent.
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: Prism::node?, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: Prism::node?, statements: StatementsNode?, subsequent: RescueNode? }
+  def deconstruct_keys(keys); end
+
+  # attr_reader exceptions: Array[Prism::node]
+  def exceptions; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def operator: () -> String?
+  def operator; end
+
+  # attr_reader operator_loc: Location?
+  def operator_loc; end
+
+  # attr_reader reference: Prism::node?
+  def reference; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # attr_reader subsequent: RescueNode?
+  def subsequent; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a rest parameter to a method, block, or lambda definition.
+#
+#     def a(*b)
+#           ^^
+#     end
+class Prism::RestParameterNode < ::Prism::Node
+  # Initialize a new RestParameterNode node.
+  #
+  # @return [RestParameterNode] a new instance of RestParameterNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).void
+  end
+  def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> RestParameterNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      name: T.nilable(Symbol),
+      name_loc: T.nilable(Prism::Location),
+      operator_loc: Prism::Location
+    ).returns(Prism::RestParameterNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader name: Symbol?
+  sig { returns(T.nilable(Symbol)) }
+  def name; end
+
+  # attr_reader name_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def name_loc; end
+
+  # def operator: () -> String
+  sig { returns(String) }
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  sig { returns(Prism::Location) }
+  def operator_loc; end
+
+  # def repeated_parameter?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def repeated_parameter?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents the result of a call to ::parse or ::parse_file. It contains
+# the requested structure, any comments that were encounters, and any errors
+# that were encountered.
+class Prism::Result
+  # Create a new result object with the given values.
+  #
+  # @return [Result] a new instance of Result
+  sig do
+    params(
+      comments: T::Array[Prism::Comment],
+      magic_comments: T::Array[Prism::MagicComment],
+      data_loc: T.nilable(Prism::Location),
+      errors: T::Array[Prism::ParseError],
+      warnings: T::Array[Prism::ParseWarning],
+      source: Prism::Source
+    ).void
+  end
+  def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
+
+  # The list of comments that were encountered during parsing.
+  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.
+  sig { returns(T.nilable(Prism::Location)) }
+  def data_loc; end
+
+  # Implement the hash pattern matching interface for Result.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns the encoding of the source code that was parsed.
+  sig { returns(Encoding) }
+  def encoding; end
+
+  # The list of errors that were generated during parsing.
+  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]
+  sig { returns(T::Boolean) }
+  def failure?; end
+
+  # The list of magic comments that were encountered during parsing.
+  sig { returns(T::Array[Prism::MagicComment]) }
+  def magic_comments; end
+
+  # A Source instance that represents the source code that was parsed.
+  sig { returns(Prism::Source) }
+  def source; end
+
+  # Returns true if there were no errors during parsing and false if there
+  # were.
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def success?; end
+
+  # The list of warnings that were generated during parsing.
+  sig { returns(T::Array[Prism::ParseWarning]) }
+  def warnings; end
+end
+
+# Represents the use of the `retry` keyword.
+#
+#     retry
+#     ^^^^^
+class Prism::RetryNode < ::Prism::Node
+  # Initialize a new RetryNode node.
+  #
+  # @return [RetryNode] a new instance of RetryNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RetryNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `return` keyword.
+#
+#     return 1
+#     ^^^^^^^^
+class Prism::ReturnNode < ::Prism::Node
+  # Initialize a new ReturnNode node.
+  #
+  # @return [ReturnNode] a new instance of ReturnNode
+  def initialize(source, node_id, location, flags, keyword_loc, arguments); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?) -> ReturnNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the `self` keyword.
+#
+#     self
+#     ^^^^
+class Prism::SelfNode < ::Prism::Node
+  # Initialize a new SelfNode node.
+  #
+  # @return [SelfNode] a new instance of SelfNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SelfNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# A module responsible for deserializing parse results.
+module Prism::Serialize
+  class << self
+    # Deserialize the AST represented by the given string into a parse result.
+    def load(input, serialized); end
+
+    # Deserialize the tokens represented by the given string into a parse
+    # result.
+    def load_tokens(source, serialized); end
+  end
+end
+
+class Prism::Serialize::Loader
+  # @return [Loader] a new instance of Loader
+  def initialize(source, serialized); end
+
+  # Returns the value of attribute constant_pool.
+  def constant_pool; end
+
+  # Returns the value of attribute constant_pool_offset.
+  def constant_pool_offset; end
+
+  # Returns the value of attribute encoding.
+  def encoding; end
+
+  # Returns the value of attribute input.
+  def input; end
+
+  # Returns the value of attribute io.
+  def io; end
+
+  def load_comments; end
+  def load_encoding; end
+  def load_header; end
+  def load_line_offsets; end
+  def load_metadata; end
+  def load_nodes; end
+  def load_result; end
+  def load_start_line; end
+  def load_tokens; end
+  def load_tokens_result; end
+
+  # Returns the value of attribute serialized.
+  def serialized; end
+
+  # Returns the value of attribute source.
+  def source; end
+
+  # Returns the value of attribute start_line.
+  def start_line; end
+
+  private
+
+  def load_constant(index); end
+  def load_double; end
+  def load_embedded_string; end
+  def load_error_level; end
+  def load_integer; end
+  def load_location; end
+  def load_location_object; end
+  def load_node; end
+  def load_optional_constant; end
+  def load_optional_location; end
+  def load_optional_location_object; end
+  def load_optional_node; end
+  def load_required_constant; end
+  def load_string; end
+  def load_uint32; end
+  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
+  def load_varuint; end
+
+  def load_warning_level; end
+end
+
+Prism::Serialize::Loader::DIAGNOSTIC_TYPES = T.let(T.unsafe(nil), Array)
+
+# StringIO is synchronized and that adds a high overhead on TruffleRuby.
+Prism::Serialize::Loader::FastStringIO = StringIO
+
+# The major version of prism that we are expecting to find in the serialized
+# strings.
+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.
+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.
+Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The token types that can be indexed by their enum values.
+Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
+#
+#     C = { a: 1 }
+#     ^^^^^^^^^^^^
+class Prism::ShareableConstantNode < ::Prism::Node
+  # Initialize a new ShareableConstantNode node.
+  #
+  # @return [ShareableConstantNode] a new instance of ShareableConstantNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, write); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode) -> ShareableConstantNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)
+    ).returns(Prism::ShareableConstantNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # def experimental_copy?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def experimental_copy?; end
+
+  # def experimental_everything?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def experimental_everything?; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def literal?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def literal?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # The constant write that should be modified with the shareability state.
+  sig do
+    returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode))
+  end
+  def write; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for shareable constant nodes.
+module Prism::ShareableConstantNodeFlags; end
+
+# constant writes that should be modified with shareable constant value experimental copy
+Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer)
+
+# constant writes that should be modified with shareable constant value experimental everything
+Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer)
+
+# constant writes that should be modified with shareable constant value literal
+Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer)
+
+# Represents a singleton class declaration involving the `class` keyword.
+#
+#     class << self end
+#     ^^^^^^^^^^^^^^^^^
+class Prism::SingletonClassNode < ::Prism::Node
+  # Initialize a new SingletonClassNode node.
+  #
+  # @return [SingletonClassNode] a new instance of SingletonClassNode
+  def initialize(source, node_id, location, flags, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Prism::node?
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def class_keyword: () -> String
+  def class_keyword; end
+
+  # attr_reader class_keyword_loc: Location
+  def class_keyword_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location) -> SingletonClassNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: Prism::node?, end_keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  # def end_keyword: () -> String
+  def end_keyword; end
+
+  # attr_reader end_keyword_loc: Location
+  def end_keyword_loc; end
+
+  # attr_reader expression: Prism::node
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # attr_reader locals: Array[Symbol]
+  def locals; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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.
+class Prism::Source
+  # Create a new source object with the given source code.
+  #
+  # @return [Source] a new instance of Source
+  sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
+  def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+
+  # Return the column number in characters for the given byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_column(byte_offset); end
+
+  # Return the character offset for the given byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def character_offset(byte_offset); end
+
+  # Returns the column number in code units for the given encoding for the
+  # given byte offset.
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_column(byte_offset, encoding); end
+
+  # Returns the offset from the start of the file for the given byte offset
+  # counting in code units for the given encoding.
+  #
+  # This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
+  # concept of code units that differs from the number of characters in other
+  # encodings, it is not captured here.
+  sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
+  def code_units_offset(byte_offset, encoding); end
+
+  # Return the column number for the given byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def column(byte_offset); end
+
+  # Returns the encoding of the source code, which is set by parameters to the
+  # parser or by the encoding magic comment.
+  sig { returns(Encoding) }
+  def encoding; end
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def line(byte_offset); end
+
+  # Returns the byte offset of the end of the line corresponding to the given
+  # byte offset.
+  def line_end(byte_offset); end
+
+  # Return the byte offset of the start of the line corresponding to the given
+  # byte offset.
+  sig { params(byte_offset: Integer).returns(Integer) }
+  def line_start(byte_offset); end
+
+  # Returns the lines of the source code as an array of strings.
+  sig { returns(T::Array[String]) }
+  def lines; end
+
+  # The list of newline byte offsets in the source code.
+  sig { returns(T::Array[Integer]) }
+  def offsets; end
+
+  # Perform a byteslice on the source code using the given byte offset and
+  # byte length.
+  sig { params(byte_offset: Integer, length: Integer).returns(String) }
+  def slice(byte_offset, length); end
+
+  # The source code that this source object represents.
+  sig { returns(String) }
+  def source; end
+
+  # The line number where this source starts.
+  sig { returns(Integer) }
+  def start_line; end
+
+  private
+
+  # Binary search through the offsets to find the line number for the given
+  # byte offset.
+  def find_line(byte_offset); end
+
+  class << self
+    # Create a new source object with the given source code. This method should
+    # be used instead of `new` and it will return either a `Source` or a
+    # specialized and more performant `ASCIISource` if no multibyte characters
+    # are present in the source code.
+    def for(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+  end
+end
+
+# Represents the use of the `__ENCODING__` keyword.
+#
+#     __ENCODING__
+#     ^^^^^^^^^^^^
+class Prism::SourceEncodingNode < ::Prism::Node
+  # Initialize a new SourceEncodingNode node.
+  #
+  # @return [SourceEncodingNode] a new instance of SourceEncodingNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceEncodingNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `__FILE__` keyword.
+#
+#     __FILE__
+#     ^^^^^^^^
+class Prism::SourceFileNode < ::Prism::Node
+  # Initialize a new SourceFileNode node.
+  #
+  # @return [SourceFileNode] a new instance of SourceFileNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, filepath); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?filepath: String) -> SourceFileNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      filepath: String
+    ).returns(Prism::SourceFileNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), filepath: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
+  sig { returns(String) }
+  def filepath; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `__LINE__` keyword.
+#
+#     __LINE__
+#     ^^^^^^^^
+class Prism::SourceLineNode < ::Prism::Node
+  # Initialize a new SourceLineNode node.
+  #
+  # @return [SourceLineNode] a new instance of SourceLineNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceLineNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the splat operator.
+#
+#     [*a]
+#      ^^
+class Prism::SplatNode < ::Prism::Node
+  # Initialize a new SplatNode node.
+  #
+  # @return [SplatNode] a new instance of SplatNode
+  def initialize(source, node_id, location, flags, operator_loc, expression); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?expression: Prism::node?) -> SplatNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? }
+  def deconstruct_keys(keys); end
+
+  # attr_reader expression: Prism::node?
+  def expression; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def operator: () -> String
+  def operator; end
+
+  # attr_reader operator_loc: Location
+  def operator_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents a set of statements contained within some scope.
+#
+#     foo; bar; baz
+#     ^^^^^^^^^^^^^
+class Prism::StatementsNode < ::Prism::Node
+  # Initialize a new StatementsNode node.
+  #
+  # @return [StatementsNode] a new instance of StatementsNode
+  def initialize(source, node_id, location, flags, body); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader body: Array[Prism::node]
+  def body; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Array[Prism::node]) -> StatementsNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for string nodes.
+module Prism::StringFlags; end
+
+# internal bytes forced the encoding to binary
+Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+Prism::StringFlags::MUTABLE = 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"
+#      ^^^^      ^^^^
+class Prism::StringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new StringNode node.
+  #
+  # @return [StringNode] a new instance of StringNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String) -> StringNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      content_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::StringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def frozen?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def frozen?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def mutable?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def mutable?; end
+
+  # def opening: () -> String?
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Occasionally it's helpful to treat a string as if it were interpolated so
+  # that there's a consistent interface for working with strings.
+  sig { returns(Prism::InterpolatedStringNode) }
+  def to_interpolated; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  sig { returns(String) }
+  def unescaped; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `super` keyword with parentheses or arguments.
+#
+#     super()
+#     ^^^^^^^
+#
+#     super foo, bar
+#     ^^^^^^^^^^^^^^
+class Prism::SuperNode < ::Prism::Node
+  # Initialize a new SuperNode node.
+  #
+  # @return [SuperNode] a new instance of SuperNode
+  def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  def arguments; end
+
+  # attr_reader block: Prism::node?
+  def block; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: Prism::node?) -> SuperNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Prism::node? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Flags for symbol nodes.
+module Prism::SymbolFlags; end
+
+# internal bytes forced the encoding to binary
+Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to US-ASCII
+Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to UTF-8
+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]
+#        ^^^
+class Prism::SymbolNode < ::Prism::Node
+  # Initialize a new SymbolNode node.
+  #
+  # @return [SymbolNode] a new instance of SymbolNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, value_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String) -> SymbolNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: T.nilable(Prism::Location),
+      value_loc: T.nilable(Prism::Location),
+      closing_loc: T.nilable(Prism::Location),
+      unescaped: String
+    ).returns(Prism::SymbolNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_us_ascii_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_us_ascii_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String?
+  sig { returns(T.nilable(String)) }
+  def opening; end
+
+  # attr_reader opening_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def opening_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  sig { returns(String) }
+  def unescaped; end
+
+  # def value: () -> String?
+  sig { returns(T.nilable(String)) }
+  def value; end
+
+  # attr_reader value_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def value_loc; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# This represents a token from the Ruby source.
+class Prism::Token
+  # Create a new token object with the given type, value, and location.
+  #
+  # @return [Token] a new instance of Token
+  sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
+  def initialize(source, type, value, location); end
+
+  # Returns true if the given other token is equal to this token.
+  sig { params(other: T.untyped).returns(T::Boolean) }
+  def ==(other); end
+
+  # Implement the hash pattern matching interface for Token.
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  # Returns a string representation of this token.
+  def inspect; end
+
+  # A Location object representing the location of this token in the source.
+  sig { returns(Prism::Location) }
+  def location; end
+
+  # Implement the pretty print interface for Token.
+  sig { params(q: T.untyped).void }
+  def pretty_print(q); end
+
+  # The type of token that this token is.
+  sig { returns(Symbol) }
+  def type; end
+
+  # A byteslice of the source that this token represents.
+  sig { returns(String) }
+  def value; end
+
+  private
+
+  # The Source object that represents the source this token came from.
+  sig { returns(Prism::Source) }
+  def source; end
+end
+
+# This module is responsible for converting the prism syntax tree into other
+# syntax trees.
+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.
+class Prism::Translation::Parser < ::Parser::Base
+  # The default encoding for Ruby files is UTF-8.
+  def default_encoding; end
+
+  # Parses a source buffer and returns the AST.
+  def parse(source_buffer); end
+
+  # Parses a source buffer and returns the AST and the source code comments.
+  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.
+  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.
+  def try_declare_numparam(node); end
+
+  sig { overridable.returns(Integer) }
+  def version; end
+
+  def yyerror; end
+
+  private
+
+  # Build the parser gem AST from the prism AST.
+  def build_ast(program, offset_cache); end
+
+  # Build the parser gem comments from the prism comments.
+  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 an array where the
+  # index is the byte offset and the value is the character offset.
+  def build_offset_cache(source); end
+
+  # Build a range from a prism location.
+  def build_range(location, offset_cache); end
+
+  # Build the parser gem tokens from the prism tokens.
+  def build_tokens(tokens, offset_cache); end
+
+  # Converts the version format handled by Parser to the format handled by Prism.
+  def convert_for_prism(version); end
+
+  # Build a diagnostic from the given prism parse error.
+  def error_diagnostic(error, offset_cache); end
+
+  # If there was a error generated during the parse, then raise an
+  # appropriate syntax error. Otherwise return the result.
+  def unwrap(result, offset_cache); end
+
+  # This is a hook to allow consumers to disable some errors if they don't
+  # want them to block creating the syntax tree.
+  #
+  # @return [Boolean]
+  def valid_error?(error); end
+
+  # This is a hook to allow consumers to disable some warnings if they don't
+  # want them to block creating the syntax tree.
+  #
+  # @return [Boolean]
+  def valid_warning?(warning); end
+
+  # Build a diagnostic from the given prism parse warning.
+  def warning_diagnostic(warning, offset_cache); end
+end
+
+# This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
+class Prism::Translation::Parser33 < ::Prism::Translation::Parser
+  sig { override.returns(Integer) }
+  def version; end
+end
+
+# This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
+class Prism::Translation::Parser34 < ::Prism::Translation::Parser
+  sig { override.returns(Integer) }
+  def version; end
+end
+
+# A visitor that knows how to convert a prism syntax tree into the
+# whitequark/parser gem's syntax tree.
+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
+  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.
+  def builder; end
+
+  # The types of values that can be forwarded in the current scope.
+  def forwarding; end
+
+  # Whether or not the current node is in a destructure.
+  def in_destructure; end
+
+  # Whether or not the current node is in a pattern.
+  def in_pattern; end
+
+  # The offset cache that is used to map between byte and character
+  # offsets in the file.
+  def offset_cache; end
+
+  # The Parser::Base instance that is being used to build the AST.
+  def parser; end
+
+  # The Parser::Source::Buffer instance that is holding a reference to the
+  # source code.
+  def source_buffer; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  def visit_block_local_variable_node(node); end
+
+  # A block on a keyword or method call.
+  #
+  # @raise [CompilationError]
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  def visit_embedded_variable_node(node); end
+
+  # begin; foo; ensure; bar; end
+  #             ^^^^^^^^^^^^
+  #
+  # @raise [CompilationError]
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  def visit_find_pattern_node(node); end
+
+  # 0..5
+  # ^^^^
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  def visit_if_node(node); end
+
+  # 1i
+  # ^^
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  #
+  # @raise [CompilationError]
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  #
+  # @raise [CompilationError]
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  def visit_integer_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  def visit_it_local_variable_read_node(node); end
+
+  # -> { it }
+  # ^^^^^^^^^
+  def visit_it_parameters_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  # ^^^^^
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  def visit_local_variable_write_node(node); end
+
+  # /foo/
+  # ^^^^^
+  # if /foo/ then end
+  #    ^^^^^
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  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.
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  def visit_module_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  #
+  # @raise [CompilationError]
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  def visit_yield_node(node); end
+
+  private
+
+  # The parser gem automatically converts \r\n to \n, meaning our offsets
+  # need to be adjusted to always subtract 1 from the length.
+  def chomped_bytesize(line); end
+
+  # Initialize a new compiler with the given option overrides, used to
+  # visit a subtree with the given options.
+  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.
+  def find_forwarding(node); end
+
+  # Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
+  def multi_target_elements(node); end
+
+  # Negate the value of a numeric node. This is a special case where you
+  # have a negative sign on one line and then a number on the next line.
+  # In normal Ruby, this will always be a method call. The parser gem,
+  # however, marks this as a numeric literal. We have to massage the tree
+  # here to get it into the correct form.
+  def numeric_negate(message_loc, receiver); 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]
+  def procarg0?(parameters); end
+
+  # Constructs a new source range from the given start and end offsets.
+  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. Importantly it does not search past newlines or comments.
+  #
+  # Note that end_offset is allowed to be nil, in which case this will
+  # search until the end of the string.
+  def srange_find(start_offset, end_offset, tokens); end
+
+  # Constructs a new source range from the given start and end offsets.
+  def srange_offsets(start_offset, end_offset); end
+
+  # Transform a location into a token that the parser gem expects.
+  def token(location); end
+
+  # Visit a block node on a call.
+  def visit_block(call, block); end
+
+  # Visit a heredoc that can be either a string or an xstring.
+  def visit_heredoc(node); end
+
+  # Visit a numeric node and account for the optional sign.
+  def visit_numeric(node, value); end
+
+  # Within the given block, track that we're within a pattern.
+  def within_pattern; end
+end
+
+# Raised when the tree is malformed or there is a bug in the compiler.
+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.
+Prism::Translation::Parser::Compiler::Range = Parser::Source::Range
+
+Prism::Translation::Parser::Diagnostic = Parser::Diagnostic
+
+# Accepts a list of prism tokens and converts them into the expected
+# format for the parser gem.
+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
+  def initialize(source_buffer, lexed, offset_cache); end
+
+  # An array of tuples that contain prism tokens and their associated lex
+  # state when they were lexed.
+  def lexed; end
+
+  # A hash that maps offsets in bytes to offsets in characters.
+  def offset_cache; end
+
+  # The Parser::Source::Buffer that the tokens were lexed from.
+  def source_buffer; end
+
+  # Convert the prism tokens into the expected format for the parser gem.
+  def to_a; end
+
+  private
+
+  # Parse a complex from the string representation.
+  def parse_complex(value); end
+
+  # Parse a float from the string representation.
+  def parse_float(value); end
+
+  # Parse an integer from the string representation.
+  def parse_integer(value); end
+
+  # Parse a rational from the string representation.
+  def parse_rational(value); end
+end
+
+# These constants represent flags in our lex state. We really, really
+# don't want to be using them and we really, really don't want to be
+# exposing them as part of our public API. Unfortunately, we don't have
+# another way of matching the exact tokens that the parser gem expects
+# without them. We should find another way to do this, but in the
+# meantime we'll hide them from the documentation and mark them as
+# private constants.
+Prism::Translation::Parser::Lexer::EXPR_BEG = T.let(T.unsafe(nil), Integer)
+
+Prism::Translation::Parser::Lexer::EXPR_LABEL = T.let(T.unsafe(nil), Integer)
+Prism::Translation::Parser::Lexer::Range = Parser::Source::Range
+
+# The direct translating of types between the two lexers.
+Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash)
+
+# 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.
+class Prism::Translation::Parser::PrismDiagnostic < ::Parser::Diagnostic
+  # Initialize a new diagnostic with the given message and location.
+  #
+  # @return [PrismDiagnostic] a new instance of PrismDiagnostic
+  def initialize(message, level, reason, location); end
+
+  # This is the cached message coming from prism.
+  def message; end
+end
+
+Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
+
+# This class provides 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. To use this class, you
+# treat `Prism::Translation::Ripper` effectively as you would treat the
+# `Ripper` class.
+#
+# Note that this class will serve the most common use cases, but Ripper's
+# API is extensive and undocumented. It relies on reporting the state of the
+# parser at any given time. We do our best to replicate that here, but
+# because it is a different architecture it is not possible to perfectly
+# replicate the behavior of Ripper.
+#
+# The main known difference is that we may omit dispatching some events in
+# some cases. This impacts the following events:
+#
+# - on_assign_error
+# - on_comma
+# - on_ignored_nl
+# - on_ignored_sp
+# - on_kw
+# - on_label_end
+# - on_lbrace
+# - on_lbracket
+# - on_lparen
+# - on_nl
+# - on_op
+# - on_operator_ambiguous
+# - on_rbrace
+# - on_rbracket
+# - on_rparen
+# - on_semicolon
+# - on_sp
+# - on_symbeg
+# - on_tstring_beg
+# - on_tstring_end
+class Prism::Translation::Ripper < ::Prism::Compiler
+  # Create a new Translation::Ripper object with the given source.
+  #
+  # @return [Ripper] a new instance of Ripper
+  def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
+
+  # The current column number of the parser.
+  def column; end
+
+  # True if the parser encountered an error during parsing.
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def error?; end
+
+  # The filename of the source being parsed.
+  def filename; end
+
+  # The current line number of the parser.
+  def lineno; end
+
+  # Parse the source and return the result.
+  sig { returns(T.untyped) }
+  def parse; end
+
+  # The source that is being parsed.
+  def source; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode.
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # @@foo, @@bar = 1
+  # ^^^^^  ^^^^^
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  def visit_embedded_variable_node(node); end
+
+  # Visit an EnsureNode node.
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  def visit_find_pattern_node(node); end
+
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # $foo, $bar = 1
+  # ^^^^  ^^^^
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  def visit_if_node(node); end
+
+  # 1i
+  # ^^
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  def visit_integer_node(node); end
+
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  def visit_it_local_variable_read_node(node); end
+
+  # -> { it }
+  # ^^^^^^^^^
+  def visit_it_parameters_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  def visit_local_variable_write_node(node); end
+
+  # if /foo/ then end
+  #    ^^^^^
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  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.
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  def visit_module_node(node); end
+
+  # (foo, bar), bar = qux
+  # ^^^^^^^^^^
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  # ^^^^^^
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  # ^^^^^^^^
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  def visit_yield_node(node); end
+
+  private
+
+  # :stopdoc:
+  def _dispatch_0; end
+
+  def _dispatch_1(_); end
+  def _dispatch_2(_, _); end
+  def _dispatch_3(_, _, _); end
+  def _dispatch_4(_, _, _, _); end
+  def _dispatch_5(_, _, _, _, _); end
+  def _dispatch_7(_, _, _, _, _, _, _); 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.
+  def bounds(location); end
+
+  # Returns true if the given node is a command node.
+  #
+  # @return [Boolean]
+  def command?(node); end
+
+  # This method is called when the parser found syntax error.
+  def compile_error(msg); end
+
+  # This method is provided by the Ripper C extension. It is called when a
+  # string needs to be dedented because of a tilde heredoc. It is expected
+  # that it will modify the string in place and return the number of bytes
+  # that were removed.
+  def dedent_string(string, width); end
+
+  def on_BEGIN(_); end
+  def on_CHAR(_); end
+  def on_END(_); end
+  def on___end__(_); end
+  def on_alias(_, _); end
+  def on_alias_error(_, _); end
+  def on_aref(_, _); end
+  def on_aref_field(_, _); end
+  def on_arg_ambiguous(_); end
+  def on_arg_paren(_); end
+  def on_args_add(_, _); end
+  def on_args_add_block(_, _); end
+  def on_args_add_star(_, _); end
+  def on_args_forward; end
+  def on_args_new; end
+  def on_array(_); end
+  def on_aryptn(_, _, _, _); end
+  def on_assign(_, _); end
+  def on_assign_error(_, _); end
+  def on_assoc_new(_, _); end
+  def on_assoc_splat(_); end
+  def on_assoclist_from_args(_); end
+  def on_backref(_); end
+  def on_backtick(_); end
+  def on_bare_assoc_hash(_); end
+  def on_begin(_); end
+  def on_binary(_, _, _); end
+  def on_block_var(_, _); end
+  def on_blockarg(_); end
+  def on_bodystmt(_, _, _, _); end
+  def on_brace_block(_, _); end
+  def on_break(_); end
+  def on_call(_, _, _); end
+  def on_case(_, _); end
+  def on_class(_, _, _); end
+  def on_class_name_error(_, _); end
+  def on_comma(_); end
+  def on_command(_, _); end
+  def on_command_call(_, _, _, _); end
+  def on_comment(_); end
+  def on_const(_); end
+  def on_const_path_field(_, _); end
+  def on_const_path_ref(_, _); end
+  def on_const_ref(_); end
+  def on_cvar(_); end
+  def on_def(_, _, _); end
+  def on_defined(_); end
+  def on_defs(_, _, _, _, _); end
+  def on_do_block(_, _); end
+  def on_dot2(_, _); end
+  def on_dot3(_, _); end
+  def on_dyna_symbol(_); end
+  def on_else(_); end
+  def on_elsif(_, _, _); end
+  def on_embdoc(_); end
+  def on_embdoc_beg(_); end
+  def on_embdoc_end(_); end
+  def on_embexpr_beg(_); end
+  def on_embexpr_end(_); end
+  def on_embvar(_); end
+  def on_ensure(_); end
+  def on_excessed_comma; end
+  def on_fcall(_); end
+  def on_field(_, _, _); end
+  def on_float(_); end
+  def on_fndptn(_, _, _, _); end
+  def on_for(_, _, _); end
+  def on_gvar(_); end
+  def on_hash(_); end
+  def on_heredoc_beg(_); end
+  def on_heredoc_dedent(_, _); end
+  def on_heredoc_end(_); end
+  def on_hshptn(_, _, _); end
+  def on_ident(_); end
+  def on_if(_, _, _); end
+  def on_if_mod(_, _); end
+  def on_ifop(_, _, _); end
+  def on_ignored_nl(_); end
+  def on_ignored_sp(_); end
+  def on_imaginary(_); end
+  def on_in(_, _, _); end
+  def on_int(_); end
+  def on_ivar(_); end
+  def on_kw(_); end
+  def on_kwrest_param(_); end
+  def on_label(_); end
+  def on_label_end(_); end
+  def on_lambda(_, _); end
+  def on_lbrace(_); end
+  def on_lbracket(_); end
+  def on_lparen(_); end
+  def on_magic_comment(_, _); end
+  def on_massign(_, _); end
+  def on_method_add_arg(_, _); end
+  def on_method_add_block(_, _); end
+  def on_mlhs_add(_, _); end
+  def on_mlhs_add_post(_, _); end
+  def on_mlhs_add_star(_, _); end
+  def on_mlhs_new; end
+  def on_mlhs_paren(_); end
+  def on_module(_, _); end
+  def on_mrhs_add(_, _); end
+  def on_mrhs_add_star(_, _); end
+  def on_mrhs_new; end
+  def on_mrhs_new_from_args(_); end
+  def on_next(_); end
+  def on_nl(_); end
+  def on_nokw_param(_); end
+  def on_op(_); end
+  def on_opassign(_, _, _); end
+  def on_operator_ambiguous(_, _); end
+  def on_param_error(_, _); end
+  def on_params(_, _, _, _, _, _, _); end
+  def on_paren(_); end
+  def on_parse_error(_); end
+  def on_period(_); end
+  def on_program(_); end
+  def on_qsymbols_add(_, _); end
+  def on_qsymbols_beg(_); end
+  def on_qsymbols_new; end
+  def on_qwords_add(_, _); end
+  def on_qwords_beg(_); end
+  def on_qwords_new; end
+  def on_rational(_); end
+  def on_rbrace(_); end
+  def on_rbracket(_); end
+  def on_redo; end
+  def on_regexp_add(_, _); end
+  def on_regexp_beg(_); end
+  def on_regexp_end(_); end
+  def on_regexp_literal(_, _); end
+  def on_regexp_new; end
+  def on_rescue(_, _, _, _); end
+  def on_rescue_mod(_, _); end
+  def on_rest_param(_); end
+  def on_retry; end
+  def on_return(_); end
+  def on_return0; end
+  def on_rparen(_); end
+  def on_sclass(_, _); end
+  def on_semicolon(_); end
+  def on_sp(_); end
+  def on_stmts_add(_, _); end
+  def on_stmts_new; end
+  def on_string_add(_, _); end
+  def on_string_concat(_, _); end
+  def on_string_content; end
+  def on_string_dvar(_); end
+  def on_string_embexpr(_); end
+  def on_string_literal(_); end
+  def on_super(_); end
+  def on_symbeg(_); end
+  def on_symbol(_); end
+  def on_symbol_literal(_); end
+  def on_symbols_add(_, _); end
+  def on_symbols_beg(_); end
+  def on_symbols_new; end
+  def on_tlambda(_); end
+  def on_tlambeg(_); end
+  def on_top_const_field(_); end
+  def on_top_const_ref(_); end
+  def on_tstring_beg(_); end
+  def on_tstring_content(_); end
+  def on_tstring_end(_); end
+  def on_unary(_, _); end
+  def on_undef(_); end
+  def on_unless(_, _, _); end
+  def on_unless_mod(_, _); end
+  def on_until(_, _); end
+  def on_until_mod(_, _); end
+  def on_var_alias(_, _); end
+  def on_var_field(_); end
+  def on_var_ref(_); end
+  def on_vcall(_); end
+  def on_void_stmt; end
+  def on_when(_, _, _); end
+  def on_while(_, _); end
+  def on_while_mod(_, _); end
+  def on_word_add(_, _); end
+  def on_word_new; end
+  def on_words_add(_, _); end
+  def on_words_beg(_); end
+  def on_words_new; end
+  def on_words_sep(_); end
+  def on_xstring_add(_, _); end
+  def on_xstring_literal(_); end
+  def on_xstring_new; end
+  def on_yield(_); end
+  def on_yield0; end
+  def on_zsuper; end
+
+  # Lazily initialize the parse result.
+  def result; end
+
+  # Returns true if there is a comma between the two locations.
+  #
+  # @return [Boolean]
+  def trailing_comma?(left, right); end
+
+  # Visit one side of an alias global variable node.
+  def visit_alias_global_variable_node_value(node); end
+
+  # Visit a list of elements, like the elements of an array or arguments.
+  def visit_arguments(elements); end
+
+  # Visit the clauses of a begin node to form an on_bodystmt call.
+  def visit_begin_node_clauses(location, node, allow_newline); end
+
+  # Visit the body of a structure that can have either a set of statements
+  # or statements wrapped in rescue/else/ensure.
+  def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end
+
+  # Visit the arguments and block of a call node and return the arguments
+  # and block as they should be used.
+  def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end
+
+  # Visit a constant path that is part of a write node.
+  def visit_constant_path_write_node_target(node); end
+
+  # Visit a destructured positional parameter node.
+  def visit_destructured_parameter_node(node); end
+
+  # Visit a string that is expressed using a <<~ heredoc.
+  def visit_heredoc_node(parts, base); end
+
+  # Ripper gives back the escaped string content but strips out the common
+  # leading whitespace. Prism gives back the unescaped string content and
+  # a location for the escaped string content. Unfortunately these don't
+  # work well together, so here we need to re-derive the common leading
+  # whitespace.
+  def visit_heredoc_node_whitespace(parts); end
+
+  # Visit a heredoc node that is representing a string.
+  def visit_heredoc_string_node(node); end
+
+  # Visit a heredoc node that is representing an xstring.
+  def visit_heredoc_x_string_node(node); end
+
+  # Visit the targets of a multi-target node.
+  def visit_multi_target_node_targets(lefts, rest, rights, skippable); end
+
+  # Visit a node that represents a number. We need to explicitly handle the
+  # unary - operator.
+  def visit_number_node(node); end
+
+  # Visit a pattern within a pattern match. This is used to bypass the
+  # parenthesis node that can be used to wrap patterns.
+  def visit_pattern_node(node); end
+
+  # Visit the list of statements of a statements node. We support nil
+  # statements in the list. This would normally not be allowed by the
+  # structure of the prism parse tree, but we manually add them here so that
+  # we can mirror Ripper's void stmt.
+  def visit_statements_node_body(body); end
+
+  # Visit an individual part of a string-like node.
+  def visit_string_content(part); end
+
+  # Visit the string content of a particular node. This method is used to
+  # split into the various token types.
+  def visit_token(token, allow_keywords = T.unsafe(nil)); end
+
+  # Dispatch a words_sep event that contains the space between the elements
+  # of list literals.
+  def visit_words_sep(opening_loc, previous, current); end
+
+  # Visit a node that represents a write value. This is used to handle the
+  # special case of an implicit array that is generated without brackets.
+  def visit_write_value(node); end
+
+  # Returns true if there is a semicolon between the two locations.
+  #
+  # @return [Boolean]
+  def void_stmt?(left, right, allow_newline); end
+
+  # This method is called when weak warning is produced by the parser.
+  # +fmt+ and +args+ is printf style.
+  def warn(fmt, *args); end
+
+  # This method is called when strong warning is produced by the parser.
+  # +fmt+ and +args+ is printf style.
+  def warning(fmt, *args); end
+
+  class << self
+    # Tokenizes the Ruby program and returns an array of an array,
+    # which is formatted like
+    # <code>[[lineno, column], type, token, state]</code>.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.lex("def m(a) nil end")
+    #     #=> [[[1,  0], :on_kw,     "def", FNAME    ],
+    #          [[1,  3], :on_sp,     " ",   FNAME    ],
+    #          [[1,  4], :on_ident,  "m",   ENDFN    ],
+    #          [[1,  5], :on_lparen, "(",   BEG|LABEL],
+    #          [[1,  6], :on_ident,  "a",   ARG      ],
+    #          [[1,  7], :on_rparen, ")",   ENDFN    ],
+    #          [[1,  8], :on_sp,     " ",   BEG      ],
+    #          [[1,  9], :on_kw,     "nil", END      ],
+    #          [[1, 12], :on_sp,     " ",   END      ],
+    #          [[1, 13], :on_kw,     "end", END      ]]
+    def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+
+    # Parses the given Ruby program read from +src+.
+    # +src+ must be a String or an IO or a object with a #gets method.
+    def parse(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
+
+    # Parses +src+ and create S-exp tree.
+    # Returns more readable tree rather than Ripper.sexp_raw.
+    # This method is mainly for developer use.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # returning +nil+ in such cases. Use the +raise_errors+ keyword
+    # to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.sexp("def m(a) nil end")
+    #       #=> [:program,
+    #            [[:def,
+    #             [:@ident, "m", [1, 4]],
+    #             [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
+    #             [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
+    def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+
+    # Parses +src+ and create S-exp tree.
+    # This method is mainly for developer use.
+    # The +filename+ argument is mostly ignored.
+    # By default, this method does not handle syntax errors in +src+,
+    # returning +nil+ in such cases. Use the +raise_errors+ keyword
+    # to raise a SyntaxError for an error in +src+.
+    #
+    #     require "ripper"
+    #     require "pp"
+    #
+    #     pp Ripper.sexp_raw("def m(a) nil end")
+    #       #=> [:program,
+    #            [:stmts_add,
+    #             [:stmts_new],
+    #             [:def,
+    #              [:@ident, "m", [1, 4]],
+    #              [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
+    #              [:bodystmt,
+    #               [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
+    #               nil,
+    #               nil,
+    #               nil]]]]
+    def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
+  end
+end
+
+# A list of all of the Ruby binary operators.
+Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
+
+# This array contains name of all ripper events.
+Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array)
+
+# A list of all of the Ruby keywords.
+Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array)
+
+# This array contains name of parser events.
+Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array)
+
+# This contains a table of all of the parser events and their
+# corresponding arity.
+Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
+
+# This array contains name of scanner events.
+Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array)
+
+# This contains a table of all of the scanner events and their
+# corresponding arity.
+Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
+
+# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+# returns the arrays of [type, *children].
+class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper
+  # :stopdoc:
+  def error; end
+
+  def on_BEGIN(*args); end
+  def on_CHAR(tok); end
+  def on_END(*args); end
+  def on___end__(tok); end
+  def on_alias(*args); end
+  def on_alias_error(*args); end
+  def on_aref(*args); end
+  def on_aref_field(*args); end
+  def on_arg_ambiguous(*args); end
+  def on_arg_paren(*args); end
+  def on_args_add(*args); end
+  def on_args_add_block(*args); end
+  def on_args_add_star(*args); end
+  def on_args_forward(*args); end
+  def on_args_new(*args); end
+  def on_array(*args); end
+  def on_aryptn(*args); end
+  def on_assign(*args); end
+  def on_assign_error(*args); end
+  def on_assoc_new(*args); end
+  def on_assoc_splat(*args); end
+  def on_assoclist_from_args(*args); end
+  def on_backref(tok); end
+  def on_backtick(tok); end
+  def on_bare_assoc_hash(*args); end
+  def on_begin(*args); end
+  def on_binary(*args); end
+  def on_block_var(*args); end
+  def on_blockarg(*args); end
+  def on_bodystmt(*args); end
+  def on_brace_block(*args); end
+  def on_break(*args); end
+  def on_call(*args); end
+  def on_case(*args); end
+  def on_class(*args); end
+  def on_class_name_error(*args); end
+  def on_comma(tok); end
+  def on_command(*args); end
+  def on_command_call(*args); end
+  def on_comment(tok); end
+  def on_const(tok); end
+  def on_const_path_field(*args); end
+  def on_const_path_ref(*args); end
+  def on_const_ref(*args); end
+  def on_cvar(tok); end
+  def on_def(*args); end
+  def on_defined(*args); end
+  def on_defs(*args); end
+  def on_do_block(*args); end
+  def on_dot2(*args); end
+  def on_dot3(*args); end
+  def on_dyna_symbol(*args); end
+  def on_else(*args); end
+  def on_elsif(*args); end
+  def on_embdoc(tok); end
+  def on_embdoc_beg(tok); end
+  def on_embdoc_end(tok); end
+  def on_embexpr_beg(tok); end
+  def on_embexpr_end(tok); end
+  def on_embvar(tok); end
+  def on_ensure(*args); end
+  def on_excessed_comma(*args); end
+  def on_fcall(*args); end
+  def on_field(*args); end
+  def on_float(tok); end
+  def on_fndptn(*args); end
+  def on_for(*args); end
+  def on_gvar(tok); end
+  def on_hash(*args); end
+  def on_heredoc_beg(tok); end
+  def on_heredoc_end(tok); end
+  def on_hshptn(*args); end
+  def on_ident(tok); end
+  def on_if(*args); end
+  def on_if_mod(*args); end
+  def on_ifop(*args); end
+  def on_ignored_nl(tok); end
+  def on_ignored_sp(tok); end
+  def on_imaginary(tok); end
+  def on_in(*args); end
+  def on_int(tok); end
+  def on_ivar(tok); end
+  def on_kw(tok); end
+  def on_kwrest_param(*args); end
+  def on_label(tok); end
+  def on_label_end(tok); end
+  def on_lambda(*args); end
+  def on_lbrace(tok); end
+  def on_lbracket(tok); end
+  def on_lparen(tok); end
+  def on_magic_comment(*args); end
+  def on_massign(*args); end
+  def on_method_add_arg(*args); end
+  def on_method_add_block(*args); end
+  def on_mlhs_add(*args); end
+  def on_mlhs_add_post(*args); end
+  def on_mlhs_add_star(*args); end
+  def on_mlhs_new(*args); end
+  def on_mlhs_paren(*args); end
+  def on_module(*args); end
+  def on_mrhs_add(*args); end
+  def on_mrhs_add_star(*args); end
+  def on_mrhs_new(*args); end
+  def on_mrhs_new_from_args(*args); end
+  def on_next(*args); end
+  def on_nl(tok); end
+  def on_nokw_param(*args); end
+  def on_op(tok); end
+  def on_opassign(*args); end
+  def on_operator_ambiguous(*args); end
+  def on_param_error(*args); end
+  def on_params(*args); end
+  def on_paren(*args); end
+  def on_period(tok); end
+  def on_program(*args); end
+  def on_qsymbols_add(*args); end
+  def on_qsymbols_beg(tok); end
+  def on_qsymbols_new(*args); end
+  def on_qwords_add(*args); end
+  def on_qwords_beg(tok); end
+  def on_qwords_new(*args); end
+  def on_rational(tok); end
+  def on_rbrace(tok); end
+  def on_rbracket(tok); end
+  def on_redo(*args); end
+  def on_regexp_add(*args); end
+  def on_regexp_beg(tok); end
+  def on_regexp_end(tok); end
+  def on_regexp_literal(*args); end
+  def on_regexp_new(*args); end
+  def on_rescue(*args); end
+  def on_rescue_mod(*args); end
+  def on_rest_param(*args); end
+  def on_retry(*args); end
+  def on_return(*args); end
+  def on_return0(*args); end
+  def on_rparen(tok); end
+  def on_sclass(*args); end
+  def on_semicolon(tok); end
+  def on_sp(tok); end
+  def on_stmts_add(*args); end
+  def on_stmts_new(*args); end
+  def on_string_add(*args); end
+  def on_string_concat(*args); end
+  def on_string_content(*args); end
+  def on_string_dvar(*args); end
+  def on_string_embexpr(*args); end
+  def on_string_literal(*args); end
+  def on_super(*args); end
+  def on_symbeg(tok); end
+  def on_symbol(*args); end
+  def on_symbol_literal(*args); end
+  def on_symbols_add(*args); end
+  def on_symbols_beg(tok); end
+  def on_symbols_new(*args); end
+  def on_tlambda(tok); end
+  def on_tlambeg(tok); end
+  def on_top_const_field(*args); end
+  def on_top_const_ref(*args); end
+  def on_tstring_beg(tok); end
+  def on_tstring_content(tok); end
+  def on_tstring_end(tok); end
+  def on_unary(*args); end
+  def on_undef(*args); end
+  def on_unless(*args); end
+  def on_unless_mod(*args); end
+  def on_until(*args); end
+  def on_until_mod(*args); end
+  def on_var_alias(*args); end
+  def on_var_field(*args); end
+  def on_var_ref(*args); end
+  def on_vcall(*args); end
+  def on_void_stmt(*args); end
+  def on_when(*args); end
+  def on_while(*args); end
+  def on_while_mod(*args); end
+  def on_word_add(*args); end
+  def on_word_new(*args); end
+  def on_words_add(*args); end
+  def on_words_beg(tok); end
+  def on_words_new(*args); end
+  def on_words_sep(tok); end
+  def on_xstring_add(*args); end
+  def on_xstring_literal(*args); end
+  def on_xstring_new(*args); end
+  def on_yield(*args); end
+  def on_yield0(*args); end
+  def on_zsuper(*args); end
+
+  private
+
+  def compile_error(mesg); end
+  def dedent_element(e, width); end
+  def on_error(mesg); end
+  def on_heredoc_dedent(val, width); end
+  def on_parse_error(mesg); 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.
+class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder
+  private
+
+  def _dispatch_event_new; end
+  def _dispatch_event_push(list, item); end
+  def on_args_add(list, item); end
+  def on_args_new; end
+  def on_heredoc_dedent(val, width); end
+  def on_mlhs_add(list, item); end
+  def on_mlhs_add_post(list, post); end
+  def on_mlhs_add_star(list, star); end
+  def on_mlhs_new; end
+  def on_mlhs_paren(list); end
+  def on_mrhs_add(list, item); end
+  def on_mrhs_new; end
+  def on_qsymbols_add(list, item); end
+  def on_qsymbols_new; end
+  def on_qwords_add(list, item); end
+  def on_qwords_new; end
+  def on_regexp_add(list, item); end
+  def on_regexp_new; end
+  def on_stmts_add(list, item); end
+  def on_stmts_new; end
+  def on_string_add(list, item); end
+  def on_symbols_add(list, item); end
+  def on_symbols_new; end
+  def on_word_add(list, item); end
+  def on_word_new; end
+  def on_words_add(list, item); end
+  def on_words_new; end
+  def on_xstring_add(list, item); end
+  def on_xstring_new; end
+end
+
+# This module is the entry-point for converting a prism syntax tree into the
+# seattlerb/ruby_parser gem's syntax tree.
+class Prism::Translation::RubyParser
+  # Parse the given source and translate it into the seattlerb/ruby_parser
+  # gem's Sexp format.
+  def parse(source, filepath = T.unsafe(nil)); end
+
+  # Parse the given file and translate it into the seattlerb/ruby_parser
+  # gem's Sexp format.
+  def parse_file(filepath); end
+
+  private
+
+  # Translate the given parse result and filepath into the
+  # seattlerb/ruby_parser gem's Sexp format.
+  def translate(result, filepath); end
+
+  class << self
+    # Parse the given source and translate it into the seattlerb/ruby_parser
+    # gem's Sexp format.
+    def parse(source, filepath = T.unsafe(nil)); end
+
+    # Parse the given file and translate it into the seattlerb/ruby_parser
+    # gem's Sexp format.
+    def parse_file(filepath); end
+  end
+end
+
+# A prism visitor that builds Sexp objects.
+class Prism::Translation::RubyParser::Compiler < ::Prism::Compiler
+  # Initialize a new compiler with the given file name.
+  #
+  # @return [Compiler] a new instance of Compiler
+  def initialize(file, in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # This is the name of the file that we are compiling. We set it on every
+  # Sexp object that is generated, and also use it to compile __FILE__
+  # nodes.
+  def file; end
+
+  # Class variables will change their type based on if they are inside of
+  # a method definition or not, so we need to track that state.
+  def in_def; end
+
+  # Some nodes will change their representation if they are inside of a
+  # pattern, so we need to track that state.
+  def in_pattern; end
+
+  # alias $foo $bar
+  # ^^^^^^^^^^^^^^^
+  def visit_alias_global_variable_node(node); end
+
+  # alias foo bar
+  # ^^^^^^^^^^^^^
+  def visit_alias_method_node(node); end
+
+  # foo => bar | baz
+  #        ^^^^^^^^^
+  def visit_alternation_pattern_node(node); end
+
+  # a and b
+  # ^^^^^^^
+  def visit_and_node(node); end
+
+  # foo(bar)
+  #     ^^^
+  def visit_arguments_node(node); end
+
+  # []
+  # ^^
+  def visit_array_node(node); end
+
+  # foo => [bar]
+  #        ^^^^^
+  def visit_array_pattern_node(node); end
+
+  # { a: 1 }
+  #   ^^^^
+  def visit_assoc_node(node); end
+
+  # def foo(**); bar(**); end
+  #                  ^^
+  #
+  # { **foo }
+  #   ^^^^^
+  def visit_assoc_splat_node(node); end
+
+  # $+
+  # ^^
+  def visit_back_reference_read_node(node); end
+
+  # begin end
+  # ^^^^^^^^^
+  def visit_begin_node(node); end
+
+  # foo(&bar)
+  #     ^^^^
+  def visit_block_argument_node(node); end
+
+  # foo { |; bar| }
+  #          ^^^
+  def visit_block_local_variable_node(node); end
+
+  # A block on a keyword or method call.
+  def visit_block_node(node); end
+
+  # def foo(&bar); end
+  #         ^^^^
+  def visit_block_parameter_node(node); end
+
+  # A block's parameters.
+  def visit_block_parameters_node(node); end
+
+  # break
+  # ^^^^^
+  #
+  # break foo
+  # ^^^^^^^^^
+  def visit_break_node(node); end
+
+  # foo.bar &&= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_and_write_node(node); end
+
+  # foo
+  # ^^^
+  #
+  # foo.bar
+  # ^^^^^^^
+  #
+  # foo.bar() {}
+  # ^^^^^^^^^^^^
+  def visit_call_node(node); end
+
+  # foo.bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_operator_write_node(node); end
+
+  # foo.bar ||= baz
+  # ^^^^^^^^^^^^^^^
+  def visit_call_or_write_node(node); end
+
+  # foo.bar, = 1
+  # ^^^^^^^
+  def visit_call_target_node(node); end
+
+  # foo => bar => baz
+  #        ^^^^^^^^^^
+  def visit_capture_pattern_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_match_node(node); end
+
+  # case foo; when bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^^^
+  def visit_case_node(node); end
+
+  # class Foo; end
+  # ^^^^^^^^^^^^^^
+  def visit_class_node(node); end
+
+  # @@foo &&= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_and_write_node(node); end
+
+  # @@foo += bar
+  # ^^^^^^^^^^^^
+  def visit_class_variable_operator_write_node(node); end
+
+  # @@foo ||= bar
+  # ^^^^^^^^^^^^^
+  def visit_class_variable_or_write_node(node); end
+
+  # @@foo
+  # ^^^^^
+  def visit_class_variable_read_node(node); end
+
+  # @@foo, = bar
+  # ^^^^^
+  def visit_class_variable_target_node(node); end
+
+  # @@foo = 1
+  # ^^^^^^^^^
+  #
+  # @@foo, @@bar = 1
+  # ^^^^^  ^^^^^
+  def visit_class_variable_write_node(node); end
+
+  # Foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_and_write_node(node); end
+
+  # Foo += bar
+  # ^^^^^^^^^^^
+  def visit_constant_operator_write_node(node); end
+
+  # Foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_constant_or_write_node(node); end
+
+  # Foo::Bar &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_and_write_node(node); end
+
+  # Foo::Bar
+  # ^^^^^^^^
+  def visit_constant_path_node(node); end
+
+  # Foo::Bar += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_constant_path_operator_write_node(node); end
+
+  # Foo::Bar ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_constant_path_or_write_node(node); end
+
+  # Foo::Bar, = baz
+  # ^^^^^^^^
+  def visit_constant_path_target_node(node); end
+
+  # Foo::Bar = 1
+  # ^^^^^^^^^^^^
+  #
+  # Foo::Foo, Bar::Bar = 1
+  # ^^^^^^^^  ^^^^^^^^
+  def visit_constant_path_write_node(node); end
+
+  # Foo
+  # ^^^
+  def visit_constant_read_node(node); end
+
+  # Foo, = bar
+  # ^^^
+  def visit_constant_target_node(node); end
+
+  # Foo = 1
+  # ^^^^^^^
+  #
+  # Foo, Bar = 1
+  # ^^^  ^^^
+  def visit_constant_write_node(node); end
+
+  # def foo; end
+  # ^^^^^^^^^^^^
+  #
+  # def self.foo; end
+  # ^^^^^^^^^^^^^^^^^
+  def visit_def_node(node); end
+
+  # defined? a
+  # ^^^^^^^^^^
+  #
+  # defined?(a)
+  # ^^^^^^^^^^^
+  def visit_defined_node(node); end
+
+  # if foo then bar else baz end
+  #                 ^^^^^^^^^^^^
+  def visit_else_node(node); end
+
+  # "foo #{bar}"
+  #      ^^^^^^
+  def visit_embedded_statements_node(node); end
+
+  # "foo #@bar"
+  #      ^^^^^
+  def visit_embedded_variable_node(node); end
+
+  # begin; foo; ensure; bar; end
+  #             ^^^^^^^^^^^^
+  def visit_ensure_node(node); end
+
+  # false
+  # ^^^^^
+  def visit_false_node(node); end
+
+  # foo => [*, bar, *]
+  #        ^^^^^^^^^^^
+  def visit_find_pattern_node(node); end
+
+  # if foo .. bar; end
+  #    ^^^^^^^^^^
+  def visit_flip_flop_node(node); end
+
+  # 1.0
+  # ^^^
+  def visit_float_node(node); end
+
+  # for foo in bar do end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_for_node(node); end
+
+  # def foo(...); bar(...); end
+  #                   ^^^
+  def visit_forwarding_arguments_node(node); end
+
+  # def foo(...); end
+  #         ^^^
+  def visit_forwarding_parameter_node(node); end
+
+  # super
+  # ^^^^^
+  #
+  # super {}
+  # ^^^^^^^^
+  def visit_forwarding_super_node(node); end
+
+  # $foo &&= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_and_write_node(node); end
+
+  # $foo += bar
+  # ^^^^^^^^^^^
+  def visit_global_variable_operator_write_node(node); end
+
+  # $foo ||= bar
+  # ^^^^^^^^^^^^
+  def visit_global_variable_or_write_node(node); end
+
+  # $foo
+  # ^^^^
+  def visit_global_variable_read_node(node); end
+
+  # $foo, = bar
+  # ^^^^
+  def visit_global_variable_target_node(node); end
+
+  # $foo = 1
+  # ^^^^^^^^
+  #
+  # $foo, $bar = 1
+  # ^^^^  ^^^^
+  def visit_global_variable_write_node(node); end
+
+  # {}
+  # ^^
+  def visit_hash_node(node); end
+
+  # foo => {}
+  #        ^^
+  def visit_hash_pattern_node(node); end
+
+  # if foo then bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar if foo
+  # ^^^^^^^^^^
+  #
+  # foo ? bar : baz
+  # ^^^^^^^^^^^^^^^
+  def visit_if_node(node); end
+
+  # 1i
+  def visit_imaginary_node(node); end
+
+  # { foo: }
+  #   ^^^^
+  def visit_implicit_node(node); end
+
+  # foo { |bar,| }
+  #           ^
+  def visit_implicit_rest_node(node); end
+
+  # case foo; in bar; end
+  # ^^^^^^^^^^^^^^^^^^^^^
+  def visit_in_node(node); end
+
+  # foo[bar] &&= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_and_write_node(node); end
+
+  # foo[bar] += baz
+  # ^^^^^^^^^^^^^^^
+  def visit_index_operator_write_node(node); end
+
+  # foo[bar] ||= baz
+  # ^^^^^^^^^^^^^^^^
+  def visit_index_or_write_node(node); end
+
+  # foo[bar], = 1
+  # ^^^^^^^^
+  def visit_index_target_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_and_write_node(node); end
+
+  # ^^^^^^^^^^^
+  def visit_instance_variable_operator_write_node(node); end
+
+  # ^^^^^^^^^^^^
+  def visit_instance_variable_or_write_node(node); end
+
+  # ^^^^
+  def visit_instance_variable_read_node(node); end
+
+  # @foo, = bar
+  # ^^^^
+  def visit_instance_variable_target_node(node); end
+
+  # ^^^^^^^^
+  #
+  # @foo, @bar = 1
+  # ^^^^  ^^^^
+  def visit_instance_variable_write_node(node); end
+
+  # 1
+  # ^
+  def visit_integer_node(node); end
+
+  # if /foo #{bar}/ then end
+  #    ^^^^^^^^^^^^
+  def visit_interpolated_match_last_line_node(node); end
+
+  # /foo #{bar}/
+  # ^^^^^^^^^^^^
+  def visit_interpolated_regular_expression_node(node); end
+
+  # "foo #{bar}"
+  # ^^^^^^^^^^^^
+  def visit_interpolated_string_node(node); end
+
+  # :"foo #{bar}"
+  # ^^^^^^^^^^^^^
+  def visit_interpolated_symbol_node(node); end
+
+  # `foo #{bar}`
+  # ^^^^^^^^^^^^
+  def visit_interpolated_x_string_node(node); end
+
+  # -> { it }
+  #      ^^
+  def visit_it_local_variable_read_node(node); end
+
+  # foo(bar: baz)
+  #     ^^^^^^^^
+  def visit_keyword_hash_node(node); end
+
+  # def foo(**bar); end
+  #         ^^^^^
+  #
+  # def foo(**); end
+  #         ^^
+  def visit_keyword_rest_parameter_node(node); end
+
+  # -> {}
+  def visit_lambda_node(node); end
+
+  # foo &&= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_and_write_node(node); end
+
+  # foo += bar
+  # ^^^^^^^^^^
+  def visit_local_variable_operator_write_node(node); end
+
+  # foo ||= bar
+  # ^^^^^^^^^^^
+  def visit_local_variable_or_write_node(node); end
+
+  # foo
+  # ^^^
+  def visit_local_variable_read_node(node); end
+
+  # foo, = bar
+  # ^^^
+  def visit_local_variable_target_node(node); end
+
+  # foo = 1
+  # ^^^^^^^
+  #
+  # foo, bar = 1
+  # ^^^  ^^^
+  def visit_local_variable_write_node(node); end
+
+  # if /foo/ then end
+  #    ^^^^^
+  def visit_match_last_line_node(node); end
+
+  # foo in bar
+  # ^^^^^^^^^^
+  def visit_match_predicate_node(node); end
+
+  # foo => bar
+  # ^^^^^^^^^^
+  def visit_match_required_node(node); end
+
+  # /(?<foo>foo)/ =~ bar
+  # ^^^^^^^^^^^^^^^^^^^^
+  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.
+  def visit_missing_node(node); end
+
+  # module Foo; end
+  # ^^^^^^^^^^^^^^^
+  def visit_module_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^
+  def visit_multi_target_node(node); end
+
+  # foo, bar = baz
+  # ^^^^^^^^^^^^^^
+  def visit_multi_write_node(node); end
+
+  # next
+  # ^^^^
+  #
+  # next foo
+  # ^^^^^^^^
+  def visit_next_node(node); end
+
+  # nil
+  # ^^^
+  def visit_nil_node(node); end
+
+  # def foo(**nil); end
+  #         ^^^^^
+  def visit_no_keywords_parameter_node(node); end
+
+  # -> { _1 + _2 }
+  # ^^^^^^^^^^^^^^
+  def visit_numbered_parameters_node(node); end
+
+  # $1
+  # ^^
+  def visit_numbered_reference_read_node(node); end
+
+  # def foo(bar: baz); end
+  #         ^^^^^^^^
+  def visit_optional_keyword_parameter_node(node); end
+
+  # def foo(bar = 1); end
+  #         ^^^^^^^
+  def visit_optional_parameter_node(node); end
+
+  # a or b
+  # ^^^^^^
+  def visit_or_node(node); end
+
+  # def foo(bar, *baz); end
+  #         ^^^^^^^^^
+  def visit_parameters_node(node); end
+
+  # ()
+  # ^^
+  #
+  # (1)
+  # ^^^
+  def visit_parentheses_node(node); end
+
+  # foo => ^(bar)
+  #        ^^^^^^
+  def visit_pinned_expression_node(node); end
+
+  # foo = 1 and bar => ^foo
+  #                    ^^^^
+  def visit_pinned_variable_node(node); end
+
+  # END {}
+  def visit_post_execution_node(node); end
+
+  # BEGIN {}
+  def visit_pre_execution_node(node); end
+
+  # The top-level program node.
+  def visit_program_node(node); end
+
+  # 0..5
+  # ^^^^
+  def visit_range_node(node); end
+
+  # 1r
+  # ^^
+  def visit_rational_node(node); end
+
+  # redo
+  # ^^^^
+  def visit_redo_node(node); end
+
+  # /foo/
+  # ^^^^^
+  def visit_regular_expression_node(node); end
+
+  # def foo(bar:); end
+  #         ^^^^
+  def visit_required_keyword_parameter_node(node); end
+
+  # def foo(bar); end
+  #         ^^^
+  def visit_required_parameter_node(node); end
+
+  # foo rescue bar
+  # ^^^^^^^^^^^^^^
+  def visit_rescue_modifier_node(node); end
+
+  # begin; rescue; end
+  #        ^^^^^^^
+  def visit_rescue_node(node); end
+
+  # def foo(*bar); end
+  #         ^^^^
+  #
+  # def foo(*); end
+  #         ^
+  def visit_rest_parameter_node(node); end
+
+  # retry
+  # ^^^^^
+  def visit_retry_node(node); end
+
+  # return
+  # ^^^^^^
+  #
+  # return 1
+  # ^^^^^^^^
+  def visit_return_node(node); end
+
+  # self
+  # ^^^^
+  def visit_self_node(node); end
+
+  # A shareable constant.
+  def visit_shareable_constant_node(node); end
+
+  # class << self; end
+  # ^^^^^^^^^^^^^^^^^^
+  def visit_singleton_class_node(node); end
+
+  # __ENCODING__
+  # ^^^^^^^^^^^^
+  def visit_source_encoding_node(node); end
+
+  # __FILE__
+  # ^^^^^^^^
+  def visit_source_file_node(node); end
+
+  # __LINE__
+  # ^^^^^^^^
+  def visit_source_line_node(node); end
+
+  # foo(*bar)
+  #     ^^^^
+  #
+  # def foo((bar, *baz)); end
+  #               ^^^^
+  #
+  # def foo(*); bar(*); end
+  #                 ^
+  def visit_splat_node(node); end
+
+  # A list of statements.
+  def visit_statements_node(node); end
+
+  # "foo"
+  # ^^^^^
+  def visit_string_node(node); end
+
+  # super(foo)
+  # ^^^^^^^^^^
+  def visit_super_node(node); end
+
+  # :foo
+  # ^^^^
+  def visit_symbol_node(node); end
+
+  # true
+  # ^^^^
+  def visit_true_node(node); end
+
+  # undef foo
+  # ^^^^^^^^^
+  def visit_undef_node(node); end
+
+  # unless foo; bar end
+  # ^^^^^^^^^^^^^^^^^^^
+  #
+  # bar unless foo
+  # ^^^^^^^^^^^^^^
+  def visit_unless_node(node); end
+
+  # until foo; bar end
+  # ^^^^^^^^^^^^^^^^^
+  #
+  # bar until foo
+  # ^^^^^^^^^^^^^
+  def visit_until_node(node); end
+
+  # case foo; when bar; end
+  #           ^^^^^^^^^^^^^
+  def visit_when_node(node); end
+
+  # while foo; bar end
+  # ^^^^^^^^^^^^^^^^^^
+  #
+  # bar while foo
+  # ^^^^^^^^^^^^^
+  def visit_while_node(node); end
+
+  # `foo`
+  # ^^^^^
+  def visit_x_string_node(node); end
+
+  # yield
+  # ^^^^^
+  #
+  # yield 1
+  # ^^^^^^^
+  def visit_yield_node(node); end
+
+  private
+
+  # If a class variable is written within a method definition, it has a
+  # different type than everywhere else.
+  def class_variable_write_type; end
+
+  # Create a new compiler with the given options.
+  def copy_compiler(in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
+
+  # Call nodes with operators following them will either be op_asgn or
+  # op_asgn2 nodes. That is determined by their call operator and their
+  # right-hand side.
+  #
+  # @return [Boolean]
+  def op_asgn?(node); end
+
+  # Call nodes with operators following them can use &. as an operator,
+  # which changes their type by prefixing "safe_".
+  def op_asgn_type(node, type); end
+
+  # Create a new Sexp object from the given prism node and arguments.
+  def s(node, *arguments); end
+
+  # Visit a block node, which will modify the AST by wrapping the given
+  # visited node in an iter node.
+  def visit_block(node, sexp, block); end
+
+  # def foo((bar, baz)); end
+  #         ^^^^^^^^^^
+  def visit_destructured_parameter(node); end
+
+  # Visit the interpolated content of the string-like node.
+  def visit_interpolated_parts(parts); end
+
+  # Pattern constants get wrapped in another layer of :const.
+  def visit_pattern_constant(node); end
+
+  # If the bounds of a range node are empty parentheses, then they do not
+  # get replaced by their usual s(:nil), but instead are s(:begin).
+  def visit_range_bounds_node(node); end
+
+  # Visit the value of a write, which will be on the right-hand side of
+  # a write operator. Because implicit arrays can have splats, those could
+  # potentially be wrapped in an svalue node.
+  def visit_write_value(node); end
+end
+
+# Represents the use of the literal `true` keyword.
+#
+#     true
+#     ^^^^
+class Prism::TrueNode < ::Prism::Node
+  # Initialize a new TrueNode node.
+  #
+  # @return [TrueNode] a new instance of TrueNode
+  def initialize(source, node_id, location, flags); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> TrueNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `undef` keyword.
+#
+#     undef :foo, :bar, :baz
+#     ^^^^^^^^^^^^^^^^^^^^^^
+class Prism::UndefNode < ::Prism::Node
+  # Initialize a new UndefNode node.
+  #
+  # @return [UndefNode] a new instance of UndefNode
+  def initialize(source, node_id, location, flags, names, keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location) -> UndefNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
+  def names; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^^^^^^^^^^^^^^^^^^^^^
+class Prism::UnlessNode < ::Prism::Node
+  # Initialize a new UnlessNode node.
+  #
+  # @return [UnlessNode] a new instance of UnlessNode
+  def initialize(source, node_id, location, flags, keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # Returns the else clause of the unless node. This method is deprecated in
+  # favor of #else_clause.
+  def consequent; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  # The else clause of the unless expression, if present.
+  #
+  #     unless cond then bar else baz end
+  #                          ^^^^^^^^
+  def else_clause; end
+
+  # def end_keyword: () -> String?
+  def end_keyword; end
+
+  # The location of the `end` keyword, if present.
+  #
+  #     unless cond then bar end
+  #                          ^^^
+  def end_keyword_loc; end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # The location of the `unless` keyword.
+  #
+  #     unless cond then bar end
+  #     ^^^^^^
+  #
+  #     bar unless cond
+  #         ^^^^^^
+  def keyword_loc; end
+
+  def newline_flag!(lines); end
+
+  # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+  #
+  #     unless cond then bar end
+  #            ^^^^
+  #
+  #     bar unless cond
+  #                ^^^^
+  def predicate; end
+
+  # The body of statements that will executed if the unless condition is
+  # falsey. Will be `nil` if no body is provided.
+  #
+  #     unless cond then bar end
+  #                      ^^^
+  def statements; end
+
+  # def then_keyword: () -> String?
+  def then_keyword; end
+
+  # The location of the `then` keyword, if present.
+  #
+  #     unless cond then bar end
+  #                 ^^^^
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^^^^^^^^^^^^^^^^^^
+class Prism::UntilNode < ::Prism::Node
+  # Initialize a new UntilNode node.
+  #
+  # @return [UntilNode] a new instance of UntilNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::UntilNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  def newline_flag!(lines); end
+
+  # attr_reader predicate: Prism::node
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # attr_reader statements: StatementsNode?
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+class Prism::Visitor < ::Prism::BasicVisitor
+  # Visit a AliasGlobalVariableNode node
+  sig { params(node: Prism::AliasGlobalVariableNode).void }
+  def visit_alias_global_variable_node(node); end
+
+  # Visit a AliasMethodNode node
+  sig { params(node: Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  # Visit a AlternationPatternNode node
+  sig { params(node: Prism::AlternationPatternNode).void }
+  def visit_alternation_pattern_node(node); end
+
+  # Visit a AndNode node
+  sig { params(node: Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  # Visit a ArgumentsNode node
+  sig { params(node: Prism::ArgumentsNode).void }
+  def visit_arguments_node(node); end
+
+  # Visit a ArrayNode node
+  sig { params(node: Prism::ArrayNode).void }
+  def visit_array_node(node); end
+
+  # Visit a ArrayPatternNode node
+  sig { params(node: Prism::ArrayPatternNode).void }
+  def visit_array_pattern_node(node); end
+
+  # Visit a AssocNode node
+  sig { params(node: Prism::AssocNode).void }
+  def visit_assoc_node(node); end
+
+  # Visit a AssocSplatNode node
+  sig { params(node: Prism::AssocSplatNode).void }
+  def visit_assoc_splat_node(node); end
+
+  # Visit a BackReferenceReadNode node
+  sig { params(node: Prism::BackReferenceReadNode).void }
+  def visit_back_reference_read_node(node); end
+
+  # Visit a BeginNode node
+  sig { params(node: Prism::BeginNode).void }
+  def visit_begin_node(node); end
+
+  # Visit a BlockArgumentNode node
+  sig { params(node: Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  # Visit a BlockLocalVariableNode node
+  sig { params(node: Prism::BlockLocalVariableNode).void }
+  def visit_block_local_variable_node(node); end
+
+  # Visit a BlockNode node
+  sig { params(node: Prism::BlockNode).void }
+  def visit_block_node(node); end
+
+  # Visit a BlockParameterNode node
+  sig { params(node: Prism::BlockParameterNode).void }
+  def visit_block_parameter_node(node); end
+
+  # Visit a BlockParametersNode node
+  sig { params(node: Prism::BlockParametersNode).void }
+  def visit_block_parameters_node(node); end
+
+  # Visit a BreakNode node
+  sig { params(node: Prism::BreakNode).void }
+  def visit_break_node(node); end
+
+  # Visit a CallAndWriteNode node
+  sig { params(node: Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  # Visit a CallNode node
+  sig { params(node: Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  # Visit a CallOperatorWriteNode node
+  sig { params(node: Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  # Visit a CallOrWriteNode node
+  sig { params(node: Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  # Visit a CallTargetNode node
+  sig { params(node: Prism::CallTargetNode).void }
+  def visit_call_target_node(node); end
+
+  # Visit a CapturePatternNode node
+  sig { params(node: Prism::CapturePatternNode).void }
+  def visit_capture_pattern_node(node); end
+
+  # Visit a CaseMatchNode node
+  sig { params(node: Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+
+  # Visit a CaseNode node
+  sig { params(node: Prism::CaseNode).void }
+  def visit_case_node(node); end
+
+  # Visit a ClassNode node
+  sig { params(node: Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  # Visit a ClassVariableAndWriteNode node
+  sig { params(node: Prism::ClassVariableAndWriteNode).void }
+  def visit_class_variable_and_write_node(node); end
+
+  # Visit a ClassVariableOperatorWriteNode node
+  sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+  def visit_class_variable_operator_write_node(node); end
+
+  # Visit a ClassVariableOrWriteNode node
+  sig { params(node: Prism::ClassVariableOrWriteNode).void }
+  def visit_class_variable_or_write_node(node); end
+
+  # Visit a ClassVariableReadNode node
+  sig { params(node: Prism::ClassVariableReadNode).void }
+  def visit_class_variable_read_node(node); end
+
+  # Visit a ClassVariableTargetNode node
+  sig { params(node: Prism::ClassVariableTargetNode).void }
+  def visit_class_variable_target_node(node); end
+
+  # Visit a ClassVariableWriteNode node
+  sig { params(node: Prism::ClassVariableWriteNode).void }
+  def visit_class_variable_write_node(node); end
+
+  # Visit a ConstantAndWriteNode node
+  sig { params(node: Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  # Visit a ConstantOperatorWriteNode node
+  sig { params(node: Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  # Visit a ConstantOrWriteNode node
+  sig { params(node: Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  # Visit a ConstantPathAndWriteNode node
+  sig { params(node: Prism::ConstantPathAndWriteNode).void }
+  def visit_constant_path_and_write_node(node); end
+
+  # Visit a ConstantPathNode node
+  sig { params(node: Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  # Visit a ConstantPathOperatorWriteNode node
+  sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+  def visit_constant_path_operator_write_node(node); end
+
+  # Visit a ConstantPathOrWriteNode node
+  sig { params(node: Prism::ConstantPathOrWriteNode).void }
+  def visit_constant_path_or_write_node(node); end
+
+  # Visit a ConstantPathTargetNode node
+  sig { params(node: Prism::ConstantPathTargetNode).void }
+  def visit_constant_path_target_node(node); end
+
+  # Visit a ConstantPathWriteNode node
+  sig { params(node: Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  # Visit a ConstantReadNode node
+  sig { params(node: Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  # Visit a ConstantTargetNode node
+  sig { params(node: Prism::ConstantTargetNode).void }
+  def visit_constant_target_node(node); end
+
+  # Visit a ConstantWriteNode node
+  sig { params(node: Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  # Visit a DefNode node
+  sig { params(node: Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  # Visit a DefinedNode node
+  sig { params(node: Prism::DefinedNode).void }
+  def visit_defined_node(node); end
+
+  # Visit a ElseNode node
+  sig { params(node: Prism::ElseNode).void }
+  def visit_else_node(node); end
+
+  # Visit a EmbeddedStatementsNode node
+  sig { params(node: Prism::EmbeddedStatementsNode).void }
+  def visit_embedded_statements_node(node); end
+
+  # Visit a EmbeddedVariableNode node
+  sig { params(node: Prism::EmbeddedVariableNode).void }
+  def visit_embedded_variable_node(node); end
+
+  # Visit a EnsureNode node
+  sig { params(node: Prism::EnsureNode).void }
+  def visit_ensure_node(node); end
+
+  # Visit a FalseNode node
+  sig { params(node: Prism::FalseNode).void }
+  def visit_false_node(node); end
+
+  # Visit a FindPatternNode node
+  sig { params(node: Prism::FindPatternNode).void }
+  def visit_find_pattern_node(node); end
+
+  # Visit a FlipFlopNode node
+  sig { params(node: Prism::FlipFlopNode).void }
+  def visit_flip_flop_node(node); end
+
+  # Visit a FloatNode node
+  sig { params(node: Prism::FloatNode).void }
+  def visit_float_node(node); end
+
+  # Visit a ForNode node
+  sig { params(node: Prism::ForNode).void }
+  def visit_for_node(node); end
+
+  # Visit a ForwardingArgumentsNode node
+  sig { params(node: Prism::ForwardingArgumentsNode).void }
+  def visit_forwarding_arguments_node(node); end
+
+  # Visit a ForwardingParameterNode node
+  sig { params(node: Prism::ForwardingParameterNode).void }
+  def visit_forwarding_parameter_node(node); end
+
+  # Visit a ForwardingSuperNode node
+  sig { params(node: Prism::ForwardingSuperNode).void }
+  def visit_forwarding_super_node(node); end
+
+  # Visit a GlobalVariableAndWriteNode node
+  sig { params(node: Prism::GlobalVariableAndWriteNode).void }
+  def visit_global_variable_and_write_node(node); end
+
+  # Visit a GlobalVariableOperatorWriteNode node
+  sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
+  def visit_global_variable_operator_write_node(node); end
+
+  # Visit a GlobalVariableOrWriteNode node
+  sig { params(node: Prism::GlobalVariableOrWriteNode).void }
+  def visit_global_variable_or_write_node(node); end
+
+  # Visit a GlobalVariableReadNode node
+  sig { params(node: Prism::GlobalVariableReadNode).void }
+  def visit_global_variable_read_node(node); end
+
+  # Visit a GlobalVariableTargetNode node
+  sig { params(node: Prism::GlobalVariableTargetNode).void }
+  def visit_global_variable_target_node(node); end
+
+  # Visit a GlobalVariableWriteNode node
+  sig { params(node: Prism::GlobalVariableWriteNode).void }
+  def visit_global_variable_write_node(node); end
+
+  # Visit a HashNode node
+  sig { params(node: Prism::HashNode).void }
+  def visit_hash_node(node); end
+
+  # Visit a HashPatternNode node
+  sig { params(node: Prism::HashPatternNode).void }
+  def visit_hash_pattern_node(node); end
+
+  # Visit a IfNode node
+  sig { params(node: Prism::IfNode).void }
+  def visit_if_node(node); end
+
+  # Visit a ImaginaryNode node
+  sig { params(node: Prism::ImaginaryNode).void }
+  def visit_imaginary_node(node); end
+
+  # Visit a ImplicitNode node
+  sig { params(node: Prism::ImplicitNode).void }
+  def visit_implicit_node(node); end
+
+  # Visit a ImplicitRestNode node
+  sig { params(node: Prism::ImplicitRestNode).void }
+  def visit_implicit_rest_node(node); end
+
+  # Visit a InNode node
+  sig { params(node: Prism::InNode).void }
+  def visit_in_node(node); end
+
+  # Visit a IndexAndWriteNode node
+  sig { params(node: Prism::IndexAndWriteNode).void }
+  def visit_index_and_write_node(node); end
+
+  # Visit a IndexOperatorWriteNode node
+  sig { params(node: Prism::IndexOperatorWriteNode).void }
+  def visit_index_operator_write_node(node); end
+
+  # Visit a IndexOrWriteNode node
+  sig { params(node: Prism::IndexOrWriteNode).void }
+  def visit_index_or_write_node(node); end
+
+  # Visit a IndexTargetNode node
+  sig { params(node: Prism::IndexTargetNode).void }
+  def visit_index_target_node(node); end
+
+  # Visit a InstanceVariableAndWriteNode node
+  sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+  def visit_instance_variable_and_write_node(node); end
+
+  # Visit a InstanceVariableOperatorWriteNode node
+  sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+  def visit_instance_variable_operator_write_node(node); end
+
+  # Visit a InstanceVariableOrWriteNode node
+  sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+  def visit_instance_variable_or_write_node(node); end
+
+  # Visit a InstanceVariableReadNode node
+  sig { params(node: Prism::InstanceVariableReadNode).void }
+  def visit_instance_variable_read_node(node); end
+
+  # Visit a InstanceVariableTargetNode node
+  sig { params(node: Prism::InstanceVariableTargetNode).void }
+  def visit_instance_variable_target_node(node); end
+
+  # Visit a InstanceVariableWriteNode node
+  sig { params(node: Prism::InstanceVariableWriteNode).void }
+  def visit_instance_variable_write_node(node); end
+
+  # Visit a IntegerNode node
+  sig { params(node: Prism::IntegerNode).void }
+  def visit_integer_node(node); end
+
+  # Visit a InterpolatedMatchLastLineNode node
+  sig { params(node: Prism::InterpolatedMatchLastLineNode).void }
+  def visit_interpolated_match_last_line_node(node); end
+
+  # Visit a InterpolatedRegularExpressionNode node
+  sig { params(node: Prism::InterpolatedRegularExpressionNode).void }
+  def visit_interpolated_regular_expression_node(node); end
+
+  # Visit a InterpolatedStringNode node
+  sig { params(node: Prism::InterpolatedStringNode).void }
+  def visit_interpolated_string_node(node); end
+
+  # Visit a InterpolatedSymbolNode node
+  sig { params(node: Prism::InterpolatedSymbolNode).void }
+  def visit_interpolated_symbol_node(node); end
+
+  # Visit a InterpolatedXStringNode node
+  sig { params(node: Prism::InterpolatedXStringNode).void }
+  def visit_interpolated_x_string_node(node); end
+
+  # Visit a ItLocalVariableReadNode node
+  sig { params(node: Prism::ItLocalVariableReadNode).void }
+  def visit_it_local_variable_read_node(node); end
+
+  # Visit a ItParametersNode node
+  sig { params(node: Prism::ItParametersNode).void }
+  def visit_it_parameters_node(node); end
+
+  # Visit a KeywordHashNode node
+  sig { params(node: Prism::KeywordHashNode).void }
+  def visit_keyword_hash_node(node); end
+
+  # Visit a KeywordRestParameterNode node
+  sig { params(node: Prism::KeywordRestParameterNode).void }
+  def visit_keyword_rest_parameter_node(node); end
+
+  # Visit a LambdaNode node
+  sig { params(node: Prism::LambdaNode).void }
+  def visit_lambda_node(node); end
+
+  # Visit a LocalVariableAndWriteNode node
+  sig { params(node: Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  # Visit a LocalVariableOperatorWriteNode node
+  sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  # Visit a LocalVariableOrWriteNode node
+  sig { params(node: Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  # Visit a LocalVariableReadNode node
+  sig { params(node: Prism::LocalVariableReadNode).void }
+  def visit_local_variable_read_node(node); end
+
+  # Visit a LocalVariableTargetNode node
+  sig { params(node: Prism::LocalVariableTargetNode).void }
+  def visit_local_variable_target_node(node); end
+
+  # Visit a LocalVariableWriteNode node
+  sig { params(node: Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  # Visit a MatchLastLineNode node
+  sig { params(node: Prism::MatchLastLineNode).void }
+  def visit_match_last_line_node(node); end
+
+  # Visit a MatchPredicateNode node
+  sig { params(node: Prism::MatchPredicateNode).void }
+  def visit_match_predicate_node(node); end
+
+  # Visit a MatchRequiredNode node
+  sig { params(node: Prism::MatchRequiredNode).void }
+  def visit_match_required_node(node); end
+
+  # Visit a MatchWriteNode node
+  sig { params(node: Prism::MatchWriteNode).void }
+  def visit_match_write_node(node); end
+
+  # Visit a MissingNode node
+  sig { params(node: Prism::MissingNode).void }
+  def visit_missing_node(node); end
+
+  # Visit a ModuleNode node
+  sig { params(node: Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  # Visit a MultiTargetNode node
+  sig { params(node: Prism::MultiTargetNode).void }
+  def visit_multi_target_node(node); end
+
+  # Visit a MultiWriteNode node
+  sig { params(node: Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  # Visit a NextNode node
+  sig { params(node: Prism::NextNode).void }
+  def visit_next_node(node); end
+
+  # Visit a NilNode node
+  sig { params(node: Prism::NilNode).void }
+  def visit_nil_node(node); end
+
+  # Visit a NoKeywordsParameterNode node
+  sig { params(node: Prism::NoKeywordsParameterNode).void }
+  def visit_no_keywords_parameter_node(node); end
+
+  # Visit a NumberedParametersNode node
+  sig { params(node: Prism::NumberedParametersNode).void }
+  def visit_numbered_parameters_node(node); end
+
+  # Visit a NumberedReferenceReadNode node
+  sig { params(node: Prism::NumberedReferenceReadNode).void }
+  def visit_numbered_reference_read_node(node); end
+
+  # Visit a OptionalKeywordParameterNode node
+  sig { params(node: Prism::OptionalKeywordParameterNode).void }
+  def visit_optional_keyword_parameter_node(node); end
+
+  # Visit a OptionalParameterNode node
+  sig { params(node: Prism::OptionalParameterNode).void }
+  def visit_optional_parameter_node(node); end
+
+  # Visit a OrNode node
+  sig { params(node: Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  # Visit a ParametersNode node
+  sig { params(node: Prism::ParametersNode).void }
+  def visit_parameters_node(node); end
+
+  # Visit a ParenthesesNode node
+  sig { params(node: Prism::ParenthesesNode).void }
+  def visit_parentheses_node(node); end
+
+  # Visit a PinnedExpressionNode node
+  sig { params(node: Prism::PinnedExpressionNode).void }
+  def visit_pinned_expression_node(node); end
+
+  # Visit a PinnedVariableNode node
+  sig { params(node: Prism::PinnedVariableNode).void }
+  def visit_pinned_variable_node(node); end
+
+  # Visit a PostExecutionNode node
+  sig { params(node: Prism::PostExecutionNode).void }
+  def visit_post_execution_node(node); end
+
+  # Visit a PreExecutionNode node
+  sig { params(node: Prism::PreExecutionNode).void }
+  def visit_pre_execution_node(node); end
+
+  # Visit a ProgramNode node
+  sig { params(node: Prism::ProgramNode).void }
+  def visit_program_node(node); end
+
+  # Visit a RangeNode node
+  sig { params(node: Prism::RangeNode).void }
+  def visit_range_node(node); end
+
+  # Visit a RationalNode node
+  sig { params(node: Prism::RationalNode).void }
+  def visit_rational_node(node); end
+
+  # Visit a RedoNode node
+  sig { params(node: Prism::RedoNode).void }
+  def visit_redo_node(node); end
+
+  # Visit a RegularExpressionNode node
+  sig { params(node: Prism::RegularExpressionNode).void }
+  def visit_regular_expression_node(node); end
+
+  # Visit a RequiredKeywordParameterNode node
+  sig { params(node: Prism::RequiredKeywordParameterNode).void }
+  def visit_required_keyword_parameter_node(node); end
+
+  # Visit a RequiredParameterNode node
+  sig { params(node: Prism::RequiredParameterNode).void }
+  def visit_required_parameter_node(node); end
+
+  # Visit a RescueModifierNode node
+  sig { params(node: Prism::RescueModifierNode).void }
+  def visit_rescue_modifier_node(node); end
+
+  # Visit a RescueNode node
+  sig { params(node: Prism::RescueNode).void }
+  def visit_rescue_node(node); end
+
+  # Visit a RestParameterNode node
+  sig { params(node: Prism::RestParameterNode).void }
+  def visit_rest_parameter_node(node); end
+
+  # Visit a RetryNode node
+  sig { params(node: Prism::RetryNode).void }
+  def visit_retry_node(node); end
+
+  # Visit a ReturnNode node
+  sig { params(node: Prism::ReturnNode).void }
+  def visit_return_node(node); end
+
+  # Visit a SelfNode node
+  sig { params(node: Prism::SelfNode).void }
+  def visit_self_node(node); end
+
+  # Visit a ShareableConstantNode node
+  sig { params(node: Prism::ShareableConstantNode).void }
+  def visit_shareable_constant_node(node); end
+
+  # Visit a SingletonClassNode node
+  sig { params(node: Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  # Visit a SourceEncodingNode node
+  sig { params(node: Prism::SourceEncodingNode).void }
+  def visit_source_encoding_node(node); end
+
+  # Visit a SourceFileNode node
+  sig { params(node: Prism::SourceFileNode).void }
+  def visit_source_file_node(node); end
+
+  # Visit a SourceLineNode node
+  sig { params(node: Prism::SourceLineNode).void }
+  def visit_source_line_node(node); end
+
+  # Visit a SplatNode node
+  sig { params(node: Prism::SplatNode).void }
+  def visit_splat_node(node); end
+
+  # Visit a StatementsNode node
+  sig { params(node: Prism::StatementsNode).void }
+  def visit_statements_node(node); end
+
+  # Visit a StringNode node
+  sig { params(node: Prism::StringNode).void }
+  def visit_string_node(node); end
+
+  # Visit a SuperNode node
+  sig { params(node: Prism::SuperNode).void }
+  def visit_super_node(node); end
+
+  # Visit a SymbolNode node
+  sig { params(node: Prism::SymbolNode).void }
+  def visit_symbol_node(node); end
+
+  # Visit a TrueNode node
+  sig { params(node: Prism::TrueNode).void }
+  def visit_true_node(node); end
+
+  # Visit a UndefNode node
+  sig { params(node: Prism::UndefNode).void }
+  def visit_undef_node(node); end
+
+  # Visit a UnlessNode node
+  sig { params(node: Prism::UnlessNode).void }
+  def visit_unless_node(node); end
+
+  # Visit a UntilNode node
+  sig { params(node: Prism::UntilNode).void }
+  def visit_until_node(node); end
+
+  # Visit a WhenNode node
+  sig { params(node: Prism::WhenNode).void }
+  def visit_when_node(node); end
+
+  # Visit a WhileNode node
+  sig { params(node: Prism::WhileNode).void }
+  def visit_while_node(node); end
+
+  # Visit a XStringNode node
+  sig { params(node: Prism::XStringNode).void }
+  def visit_x_string_node(node); end
+
+  # Visit a YieldNode node
+  sig { params(node: Prism::YieldNode).void }
+  def visit_yield_node(node); end
+end
+
+# Represents the use of the `when` keyword within a case statement.
+#
+#     case true
+#     when true
+#     ^^^^^^^^^
+#     end
+class Prism::WhenNode < ::Prism::Node
+  # Initialize a new WhenNode node.
+  #
+  # @return [WhenNode] a new instance of WhenNode
+  def initialize(source, node_id, location, flags, keyword_loc, conditions, then_keyword_loc, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # attr_reader conditions: Array[Prism::node]
+  def conditions; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # attr_reader statements: StatementsNode?
+  def statements; end
+
+  # def then_keyword: () -> String?
+  def then_keyword; end
+
+  # attr_reader then_keyword_loc: Location?
+  def then_keyword_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    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
+#     ^^^^^^^^^^^^^^^^^^^^
+class Prism::WhileNode < ::Prism::Node
+  # Initialize a new WhileNode node.
+  #
+  # @return [WhileNode] a new instance of WhileNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).void
+  end
+  def initialize(source, node_id, location, flags, keyword_loc, closing_loc, predicate, statements); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def begin_modifier?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def begin_modifier?; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String?
+  sig { returns(T.nilable(String)) }
+  def closing; end
+
+  # attr_reader closing_loc: Location?
+  sig { returns(T.nilable(Prism::Location)) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      keyword_loc: Prism::Location,
+      closing_loc: T.nilable(Prism::Location),
+      predicate: Prism::Node,
+      statements: T.nilable(Prism::StatementsNode)
+    ).returns(Prism::WhileNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  sig { returns(String) }
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  sig { returns(Prism::Location) }
+  def keyword_loc; end
+
+  def newline_flag!(lines); end
+
+  # attr_reader predicate: Prism::node
+  sig { returns(Prism::Node) }
+  def predicate; end
+
+  # attr_reader statements: StatementsNode?
+  sig { returns(T.nilable(Prism::StatementsNode)) }
+  def statements; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents an xstring literal with no interpolation.
+#
+#     `foo`
+#     ^^^^^
+class Prism::XStringNode < ::Prism::Node
+  include ::Prism::HeredocQuery
+
+  # Initialize a new XStringNode node.
+  #
+  # @return [XStringNode] a new instance of XStringNode
+  sig do
+    params(
+      source: Prism::Source,
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).void
+  end
+  def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
+  def accept(visitor); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def child_nodes; end
+
+  # def closing: () -> String
+  sig { returns(String) }
+  def closing; end
+
+  # attr_reader closing_loc: Location
+  sig { returns(Prism::Location) }
+  def closing_loc; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  sig { override.returns(T::Array[Prism::Node]) }
+  def compact_child_nodes; end
+
+  # def content: () -> String
+  sig { returns(String) }
+  def content; end
+
+  # attr_reader content_loc: Location
+  sig { returns(Prism::Location) }
+  def content_loc; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode
+  sig do
+    params(
+      node_id: Integer,
+      location: Prism::Location,
+      flags: Integer,
+      opening_loc: Prism::Location,
+      content_loc: Prism::Location,
+      closing_loc: Prism::Location,
+      unescaped: String
+    ).returns(Prism::XStringNode)
+  end
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
+  sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def forced_binary_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_binary_encoding?; end
+
+  # def forced_utf8_encoding?: () -> bool
+  #
+  # @return [Boolean]
+  sig { returns(T::Boolean) }
+  def forced_utf8_encoding?; end
+
+  sig { returns(T::Boolean) }
+  def heredoc?; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def opening: () -> String
+  sig { returns(String) }
+  def opening; end
+
+  # attr_reader opening_loc: Location
+  sig { returns(Prism::Location) }
+  def opening_loc; end
+
+  # Occasionally it's helpful to treat a string as if it were interpolated so
+  # that there's a consistent interface for working with strings.
+  sig { returns(Prism::InterpolatedXStringNode) }
+  def to_interpolated; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  # attr_reader unescaped: String
+  sig { returns(String) }
+  def unescaped; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
+
+# Represents the use of the `yield` keyword.
+#
+#     yield 1
+#     ^^^^^^^
+class Prism::YieldNode < ::Prism::Node
+  # Initialize a new YieldNode node.
+  #
+  # @return [YieldNode] a new instance of YieldNode
+  def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc); end
+
+  # Implements case-equality for the node. This is effectively == but without
+  # comparing the value of locations. Locations are checked only for presence.
+  def ===(other); end
+
+  # def accept: (Visitor visitor) -> void
+  def accept(visitor); end
+
+  # attr_reader arguments: ArgumentsNode?
+  def arguments; end
+
+  # def child_nodes: () -> Array[nil | Node]
+  def child_nodes; end
+
+  # def comment_targets: () -> Array[Node | Location]
+  def comment_targets; end
+
+  # def compact_child_nodes: () -> Array[Node]
+  def compact_child_nodes; end
+
+  # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?) -> YieldNode
+  def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end
+
+  # def child_nodes: () -> Array[nil | Node]
+  # def deconstruct: () -> Array[nil | Node]
+  def deconstruct; end
+
+  # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? }
+  def deconstruct_keys(keys); end
+
+  sig { override.returns(T::Array[Prism::Reflection::Field]) }
+  def fields; end
+
+  # def inspect -> String
+  sig { override.returns(String) }
+  def inspect; end
+
+  # def keyword: () -> String
+  def keyword; end
+
+  # attr_reader keyword_loc: Location
+  def keyword_loc; end
+
+  # def lparen: () -> String?
+  def lparen; end
+
+  # attr_reader lparen_loc: Location?
+  def lparen_loc; end
+
+  # def rparen: () -> String?
+  def rparen; end
+
+  # attr_reader rparen_loc: Location?
+  def rparen_loc; end
+
+  # Return a symbol representation of this node type. See `Node#type`.
+  sig { override.returns(Symbol) }
+  def type; end
+
+  class << self
+    # Return a symbol representation of this node type. See `Node::type`.
+    def type; end
+  end
+end
diff --git a/sorbet/rbi/gems/rbi@0.1.14.rbi b/sorbet/rbi/gems/rbi@0.2.0.rbi
similarity index 69%
rename from sorbet/rbi/gems/rbi@0.1.14.rbi
rename to sorbet/rbi/gems/rbi@0.2.0.rbi
index 504b926..8624c70 100644
--- a/sorbet/rbi/gems/rbi@0.1.14.rbi
+++ b/sorbet/rbi/gems/rbi@0.2.0.rbi
@@ -5,24 +5,18 @@
 # Please instead update this file by running `bin/tapioca gem rbi`.
 
 
-# source://rbi//lib/rbi.rb#7
 module RBI; end
 
-# source://rbi//lib/rbi/model.rb#1043
 class RBI::Arg < ::RBI::Node
-  # source://rbi//lib/rbi/model.rb#1055
   sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void }
   def initialize(value, loc: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#1061
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#1066
   sig { returns(::String) }
   def to_s; end
 
-  # source://rbi//lib/rbi/model.rb#1047
   sig { returns(::String) }
   def value; end
 end
@@ -30,14 +24,11 @@ end
 # Attributes
 #
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#351
 class RBI::Attr < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#376
   sig do
     params(
       name: ::Symbol,
@@ -50,50 +41,37 @@ class RBI::Attr < ::RBI::NodeWithComments
   end
   def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#414
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
   # @abstract
-  #
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#61
   sig { abstract.returns(T::Array[::RBI::Method]) }
   def convert_to_methods; end
 
   # @abstract
-  #
-  # source://rbi//lib/rbi/model.rb#384
   sig { abstract.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/index.rb#113
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#422
   sig { override.params(other: ::RBI::Node).void }
   def merge_with(other); end
 
-  # source://rbi//lib/rbi/model.rb#358
   sig { returns(T::Array[::Symbol]) }
   def names; end
 
-  # source://rbi//lib/rbi/model.rb#364
   sig { returns(T::Array[::RBI::Sig]) }
   def sigs; end
 
-  # source://rbi//lib/rbi/model.rb#361
   sig { returns(::RBI::Visibility) }
   def visibility; end
 
   # @return [Visibility]
-  #
-  # source://rbi//lib/rbi/model.rb#361
   def visibility=(_arg0); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#89
   sig do
     params(
       name: ::String,
@@ -105,12 +83,11 @@ class RBI::Attr < ::RBI::NodeWithComments
   end
   def create_getter_method(name, sig, visibility, loc, comments); end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#110
   sig do
     params(
       name: ::String,
       sig: T.nilable(::RBI::Sig),
-      attribute_type: T.nilable(::String),
+      attribute_type: T.nilable(T.any(::RBI::Type, ::String)),
       visibility: ::RBI::Visibility,
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment]
@@ -119,15 +96,11 @@ class RBI::Attr < ::RBI::NodeWithComments
   def create_setter_method(name, sig, attribute_type, visibility, loc, comments); end
 
   # @raise [UnexpectedMultipleSigsError]
-  #
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#66
-  sig(:final) { returns([T.nilable(::RBI::Sig), T.nilable(::String)]) }
+  sig(:final) { returns([T.nilable(::RBI::Sig), T.nilable(T.any(::RBI::Type, ::String))]) }
   def parse_sig; end
 end
 
-# source://rbi//lib/rbi/model.rb#387
 class RBI::AttrAccessor < ::RBI::Attr
-  # source://rbi//lib/rbi/model.rb#401
   sig do
     params(
       name: ::Symbol,
@@ -141,26 +114,20 @@ class RBI::AttrAccessor < ::RBI::Attr
   end
   def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#454
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#140
   sig { override.returns(T::Array[::RBI::Method]) }
   def convert_to_methods; end
 
-  # source://rbi//lib/rbi/model.rb#407
   sig { override.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/model.rb#413
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#419
 class RBI::AttrReader < ::RBI::Attr
-  # source://rbi//lib/rbi/model.rb#433
   sig do
     params(
       name: ::Symbol,
@@ -174,26 +141,20 @@ class RBI::AttrReader < ::RBI::Attr
   end
   def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#436
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#154
   sig { override.returns(T::Array[::RBI::Method]) }
   def convert_to_methods; end
 
-  # source://rbi//lib/rbi/model.rb#439
   sig { override.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/model.rb#445
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#451
 class RBI::AttrWriter < ::RBI::Attr
-  # source://rbi//lib/rbi/model.rb#465
   sig do
     params(
       name: ::Symbol,
@@ -207,35 +168,26 @@ class RBI::AttrWriter < ::RBI::Attr
   end
   def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#445
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#163
   sig { override.returns(T::Array[::RBI::Method]) }
   def convert_to_methods; end
 
-  # source://rbi//lib/rbi/model.rb#471
   sig { override.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/model.rb#477
   sig { override.returns(::String) }
   def to_s; end
 end
 
 # An arbitrary blank line that can be added both in trees and comments
-#
-# source://rbi//lib/rbi/model.rb#76
 class RBI::BlankLine < ::RBI::Comment
-  # source://rbi//lib/rbi/model.rb#80
   sig { params(loc: T.nilable(::RBI::Loc)).void }
   def initialize(loc: T.unsafe(nil)); end
 end
 
-# source://rbi//lib/rbi/model.rb#816
 class RBI::BlockParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#827
   sig do
     params(
       name: ::String,
@@ -246,18 +198,14 @@ class RBI::BlockParam < ::RBI::Param
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#838
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#833
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#220
 class RBI::Class < ::RBI::Scope
-  # source://rbi//lib/rbi/model.rb#238
   sig do
     params(
       name: ::String,
@@ -269,50 +217,36 @@ class RBI::Class < ::RBI::Scope
   end
   def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#378
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#246
   sig { override.returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/model.rb#224
   sig { returns(::String) }
   def name; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#224
   def name=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#227
   sig { returns(T.nilable(::String)) }
   def superclass_name; end
 
   # @return [String, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#227
   def superclass_name=(_arg0); end
 end
 
-# source://rbi//lib/rbi/model.rb#55
 class RBI::Comment < ::RBI::Node
-  # source://rbi//lib/rbi/model.rb#62
   sig { params(text: ::String, loc: T.nilable(::RBI::Loc)).void }
   def initialize(text, loc: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#68
   sig { params(other: ::Object).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#59
   sig { returns(::String) }
   def text; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#59
   def text=(_arg0); end
 end
 
@@ -330,39 +264,27 @@ end
 #   >>>>>>> right
 # end
 # ~~~
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#591
 class RBI::ConflictTree < ::RBI::Tree
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#601
   sig { params(left_name: ::String, right_name: ::String).void }
   def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#595
   sig { returns(::RBI::Tree) }
   def left; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#598
   sig { returns(::String) }
   def left_name; end
 
   # @return [Tree]
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#595
   def right; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#598
   def right_name; end
 end
 
 # Consts
-#
-# source://rbi//lib/rbi/model.rb#314
 class RBI::Const < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#329
   sig do
     params(
       name: ::String,
@@ -374,43 +296,31 @@ class RBI::Const < ::RBI::NodeWithComments
   end
   def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#405
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#337
   sig { returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/index.rb#103
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#318
   sig { returns(::String) }
   def name; end
 
-  # source://rbi//lib/rbi/model.rb#344
   sig { override.returns(::String) }
   def to_s; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#318
   def value; end
 end
 
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#351
 class RBI::DuplicateNodeError < ::RBI::Error; end
-
-# source://rbi//lib/rbi.rb#8
 class RBI::Error < ::StandardError; end
 
-# source://rbi//lib/rbi/model.rb#891
 class RBI::Extend < ::RBI::Mixin
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#903
   sig do
     params(
       name: ::String,
@@ -422,22 +332,17 @@ class RBI::Extend < ::RBI::Mixin
   end
   def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#504
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/index.rb#143
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#909
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#139
 class RBI::File
-  # source://rbi//lib/rbi/model.rb#158
   sig do
     params(
       strictness: T.nilable(::String),
@@ -447,24 +352,18 @@ class RBI::File
   end
   def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#166
   sig { params(node: ::RBI::Node).void }
   def <<(node); end
 
-  # source://rbi//lib/rbi/model.rb#149
   sig { returns(T::Array[::RBI::Comment]) }
   def comments; end
 
   # @return [Array<Comment>]
-  #
-  # source://rbi//lib/rbi/model.rb#149
   def comments=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#171
   sig { returns(T::Boolean) }
   def empty?; end
 
-  # source://rbi//lib/rbi/printer.rb#744
   sig do
     params(
       out: T.any(::IO, ::StringIO),
@@ -475,110 +374,86 @@ class RBI::File
   end
   def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#143
   sig { returns(::RBI::Tree) }
   def root; end
 
   # @return [Tree]
-  #
-  # source://rbi//lib/rbi/model.rb#143
   def root=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#146
   sig { returns(T.nilable(::String)) }
   def strictness; end
 
   # @return [String, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#146
   def strictness=(_arg0); end
 
-  # source://rbi//lib/rbi/printer.rb#750
   sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
   def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 end
 
-# source://rbi//lib/rbi/formatter.rb#5
 class RBI::Formatter
-  # source://rbi//lib/rbi/formatter.rb#24
   sig do
     params(
       add_sig_templates: T::Boolean,
       group_nodes: T::Boolean,
       max_line_length: T.nilable(::Integer),
       nest_singleton_methods: T::Boolean,
-      nest_non_public_methods: T::Boolean,
+      nest_non_public_members: T::Boolean,
       sort_nodes: T::Boolean
     ).void
   end
-  def initialize(add_sig_templates: T.unsafe(nil), group_nodes: T.unsafe(nil), max_line_length: T.unsafe(nil), nest_singleton_methods: T.unsafe(nil), nest_non_public_methods: T.unsafe(nil), sort_nodes: T.unsafe(nil)); end
+  def initialize(add_sig_templates: T.unsafe(nil), group_nodes: T.unsafe(nil), max_line_length: T.unsafe(nil), nest_singleton_methods: T.unsafe(nil), nest_non_public_members: T.unsafe(nil), sort_nodes: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/formatter.rb#47
   sig { params(file: ::RBI::File).void }
   def format_file(file); end
 
-  # source://rbi//lib/rbi/formatter.rb#52
   sig { params(tree: ::RBI::Tree).void }
   def format_tree(tree); end
 
-  # source://rbi//lib/rbi/formatter.rb#12
   sig { returns(T.nilable(::Integer)) }
   def max_line_length; end
 
   # @return [Integer, nil]
-  #
-  # source://rbi//lib/rbi/formatter.rb#12
   def max_line_length=(_arg0); end
 
-  # source://rbi//lib/rbi/formatter.rb#41
   sig { params(file: ::RBI::File).returns(::String) }
   def print_file(file); end
 
-  # source://rbi//lib/rbi/formatter.rb#9
   sig { params(sort_nodes: T::Boolean).returns(T::Boolean) }
   def sort_nodes=(sort_nodes); end
 end
 
-# source://rbi//lib/rbi/rewriters/group_nodes.rb#87
 class RBI::Group < ::RBI::Tree
-  # source://rbi//lib/rbi/rewriters/group_nodes.rb#94
   sig { params(kind: ::RBI::Group::Kind).void }
   def initialize(kind); end
 
-  # source://rbi//lib/rbi/rewriters/group_nodes.rb#91
   sig { returns(::RBI::Group::Kind) }
   def kind; end
 end
 
-# source://rbi//lib/rbi/rewriters/group_nodes.rb#99
 class RBI::Group::Kind < ::T::Enum
   enums do
-    Mixins = new
-    RequiredAncestors = new
-    Helpers = new
-    TypeMembers = new
-    MixesInClassMethods = new
-    Sends = new
     Attrs = new
-    TStructFields = new
-    TEnums = new
+    Consts = new
+    Helpers = new
     Inits = new
     Methods = new
+    MixesInClassMethods = new
+    Mixins = new
+    RequiredAncestors = new
+    Sends = new
     SingletonClasses = new
-    Consts = new
+    TEnums = new
+    TStructFields = new
+    TypeMembers = new
   end
 end
 
-# source://rbi//lib/rbi/rewriters/group_nodes.rb#5
 class RBI::GroupNodesError < ::RBI::Error; end
 
 # Sorbet's misc.
-#
-# source://rbi//lib/rbi/model.rb#1374
 class RBI::Helper < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1388
   sig do
     params(
       name: ::String,
@@ -589,28 +464,22 @@ class RBI::Helper < ::RBI::NodeWithComments
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#522
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/index.rb#173
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1378
   sig { returns(::String) }
   def name; end
 
-  # source://rbi//lib/rbi/model.rb#1395
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#868
 class RBI::Include < ::RBI::Mixin
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#880
   sig do
     params(
       name: ::String,
@@ -622,49 +491,38 @@ class RBI::Include < ::RBI::Mixin
   end
   def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#495
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/index.rb#133
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#886
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/index.rb#5
 class RBI::Index < ::RBI::Visitor
-  # source://rbi//lib/rbi/index.rb#21
   sig { void }
   def initialize; end
 
-  # source://rbi//lib/rbi/index.rb#32
   sig { params(id: ::String).returns(T::Array[::RBI::Node]) }
   def [](id); end
 
-  # source://rbi//lib/rbi/index.rb#37
   sig { params(nodes: ::RBI::Node).void }
   def index(*nodes); end
 
-  # source://rbi//lib/rbi/index.rb#27
   sig { returns(T::Array[::String]) }
   def keys; end
 
-  # source://rbi//lib/rbi/index.rb#42
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/index.rb#59
   sig { params(node: T.all(::RBI::Indexable, ::RBI::Node)).void }
   def index_node(node); end
 
   class << self
-    # source://rbi//lib/rbi/index.rb#13
     sig { params(node: ::RBI::Node).returns(::RBI::Index) }
     def index(*node); end
   end
@@ -673,8 +531,6 @@ end
 # A Node that can be referred to by a unique ID inside an index
 #
 # @abstract Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/index.rb#74
 module RBI::Indexable
   interface!
 
@@ -684,34 +540,25 @@ module RBI::Indexable
   # getter and the setter.
   #
   # @abstract
-  #
-  # source://rbi//lib/rbi/index.rb#85
   sig { abstract.returns(T::Array[::String]) }
   def index_ids; end
 end
 
-# source://rbi//lib/rbi/model.rb#1071
 class RBI::KwArg < ::RBI::Arg
-  # source://rbi//lib/rbi/model.rb#1084
   sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void }
   def initialize(keyword, value, loc: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#1090
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#1075
   sig { returns(::String) }
   def keyword; end
 
-  # source://rbi//lib/rbi/model.rb#1095
   sig { returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#757
 class RBI::KwOptParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#772
   sig do
     params(
       name: ::String,
@@ -723,22 +570,17 @@ class RBI::KwOptParam < ::RBI::Param
   end
   def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#784
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#779
   sig { override.returns(::String) }
   def to_s; end
 
-  # source://rbi//lib/rbi/model.rb#761
   sig { returns(::String) }
   def value; end
 end
 
-# source://rbi//lib/rbi/model.rb#730
 class RBI::KwParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#741
   sig do
     params(
       name: ::String,
@@ -749,18 +591,14 @@ class RBI::KwParam < ::RBI::Param
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#752
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#747
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#789
 class RBI::KwRestParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#800
   sig do
     params(
       name: ::String,
@@ -771,18 +609,14 @@ class RBI::KwRestParam < ::RBI::Param
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#811
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#806
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/loc.rb#5
 class RBI::Loc
-  # source://rbi//lib/rbi/loc.rb#38
   sig do
     params(
       file: T.nilable(::String),
@@ -795,48 +629,34 @@ class RBI::Loc
   def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end
 
   # @return [Integer, nil]
-  #
-  # source://rbi//lib/rbi/loc.rb#27
   def begin_column; end
 
-  # source://rbi//lib/rbi/loc.rb#27
   sig { returns(T.nilable(::Integer)) }
   def begin_line; end
 
   # @return [Integer, nil]
-  #
-  # source://rbi//lib/rbi/loc.rb#27
   def end_column; end
 
   # @return [Integer, nil]
-  #
-  # source://rbi//lib/rbi/loc.rb#27
   def end_line; end
 
-  # source://rbi//lib/rbi/loc.rb#24
   sig { returns(T.nilable(::String)) }
   def file; end
 
-  # source://rbi//lib/rbi/loc.rb#56
   sig { returns(T.nilable(::String)) }
   def source; end
 
-  # source://rbi//lib/rbi/loc.rb#47
   sig { returns(::String) }
   def to_s; end
 
   class << self
-    # source://rbi//lib/rbi/loc.rb#12
     sig { params(file: ::String, prism_location: ::Prism::Location).returns(::RBI::Loc) }
     def from_prism(file, prism_location); end
   end
 end
 
 # A tree that _might_ contain conflicts
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#330
 class RBI::MergeTree < ::RBI::Tree
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#344
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -847,18 +667,14 @@ class RBI::MergeTree < ::RBI::Tree
   end
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), conflicts: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#334
   sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
   def conflicts; end
 end
 
 # Methods and args
-#
-# source://rbi//lib/rbi/model.rb#485
 class RBI::Method < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#515
   sig do
     params(
       name: ::String,
@@ -873,43 +689,34 @@ class RBI::Method < ::RBI::NodeWithComments
   end
   def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#535
   sig { params(param: ::RBI::Param).void }
   def <<(param); end
 
-  # source://rbi//lib/rbi/model.rb#570
   sig { params(name: ::String).void }
   def add_block_param(name); end
 
-  # source://rbi//lib/rbi/model.rb#560
   sig { params(name: ::String, default_value: ::String).void }
   def add_kw_opt_param(name, default_value); end
 
-  # source://rbi//lib/rbi/model.rb#555
   sig { params(name: ::String).void }
   def add_kw_param(name); end
 
-  # source://rbi//lib/rbi/model.rb#565
   sig { params(name: ::String).void }
   def add_kw_rest_param(name); end
 
-  # source://rbi//lib/rbi/model.rb#545
   sig { params(name: ::String, default_value: ::String).void }
   def add_opt_param(name, default_value); end
 
-  # source://rbi//lib/rbi/model.rb#540
   sig { params(name: ::String).void }
   def add_param(name); end
 
-  # source://rbi//lib/rbi/model.rb#550
   sig { params(name: ::String).void }
   def add_rest_param(name); end
 
-  # source://rbi//lib/rbi/model.rb#587
   sig do
     params(
       params: T::Array[::RBI::SigParam],
-      return_type: T.nilable(::String),
+      return_type: T.any(::RBI::Type, ::String),
       is_abstract: T::Boolean,
       is_override: T::Boolean,
       is_overridable: T::Boolean,
@@ -921,72 +728,52 @@ class RBI::Method < ::RBI::NodeWithComments
   end
   def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#463
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#613
   sig { returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/index.rb#123
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#495
   sig { returns(T::Boolean) }
   def is_singleton; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#495
   def is_singleton=(_arg0); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#472
   sig { override.params(other: ::RBI::Node).void }
   def merge_with(other); end
 
-  # source://rbi//lib/rbi/model.rb#489
   sig { returns(::String) }
   def name; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#489
   def name=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#492
   sig { returns(T::Array[::RBI::Param]) }
   def params; end
 
-  # source://rbi//lib/rbi/model.rb#501
   sig { returns(T::Array[::RBI::Sig]) }
   def sigs; end
 
   # @return [Array<Sig>]
-  #
-  # source://rbi//lib/rbi/model.rb#501
   def sigs=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#622
   sig { override.returns(::String) }
   def to_s; end
 
-  # source://rbi//lib/rbi/model.rb#498
   sig { returns(::RBI::Visibility) }
   def visibility; end
 
   # @return [Visibility]
-  #
-  # source://rbi//lib/rbi/model.rb#498
   def visibility=(_arg0); end
 end
 
-# source://rbi//lib/rbi/model.rb#1435
 class RBI::MixesInClassMethods < ::RBI::Mixin
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1447
   sig do
     params(
       name: ::String,
@@ -998,15 +785,12 @@ class RBI::MixesInClassMethods < ::RBI::Mixin
   end
   def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#513
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/index.rb#153
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1453
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -1014,12 +798,9 @@ end
 # Mixins
 #
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#845
 class RBI::Mixin < ::RBI::NodeWithComments
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#862
   sig do
     params(
       name: ::String,
@@ -1030,18 +811,14 @@ class RBI::Mixin < ::RBI::NodeWithComments
   end
   def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#486
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#852
   sig { returns(T::Array[::String]) }
   def names; end
 end
 
-# source://rbi//lib/rbi/model.rb#192
 class RBI::Module < ::RBI::Scope
-  # source://rbi//lib/rbi/model.rb#206
   sig do
     params(
       name: ::String,
@@ -1052,77 +829,55 @@ class RBI::Module < ::RBI::Scope
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#387
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#213
   sig { override.returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/model.rb#196
   sig { returns(::String) }
   def name; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#196
   def name=(_arg0); end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#7
 class RBI::Node
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#20
   sig { params(loc: T.nilable(::RBI::Loc)).void }
   def initialize(loc: T.unsafe(nil)); end
 
   # Can `self` and `_other` be merged into a single definition?
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#287
   sig { params(_other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(_other); end
 
-  # source://rbi//lib/rbi/model.rb#26
   sig { void }
   def detach; end
 
-  # source://rbi//lib/rbi/model.rb#17
   sig { returns(T.nilable(::RBI::Loc)) }
   def loc; end
 
   # @return [Loc, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#17
   def loc=(_arg0); end
 
   # Merge `self` and `other` into a single definition
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#293
   sig { params(other: ::RBI::Node).void }
   def merge_with(other); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#296
   sig { returns(T.nilable(::RBI::ConflictTree)) }
   def parent_conflict_tree; end
 
-  # source://rbi//lib/rbi/model.rb#48
   sig { returns(T.nilable(::RBI::Scope)) }
   def parent_scope; end
 
-  # source://rbi//lib/rbi/model.rb#14
   sig { returns(T.nilable(::RBI::Tree)) }
   def parent_tree; end
 
   # @return [Tree, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#14
   def parent_tree=(_arg0); end
 
-  # source://rbi//lib/rbi/printer.rb#768
   sig do
     params(
       out: T.any(::IO, ::StringIO),
@@ -1134,55 +889,40 @@ class RBI::Node
   def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 
   # @raise [ReplaceNodeError]
-  #
-  # source://rbi//lib/rbi/model.rb#35
   sig { params(node: ::RBI::Node).void }
   def replace(node); end
 
-  # source://rbi//lib/rbi/rewriters/filter_versions.rb#94
   sig { params(version: ::Gem::Version).returns(T::Boolean) }
   def satisfies_version?(version); end
 
-  # source://rbi//lib/rbi/printer.rb#774
   sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) }
   def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#85
 class RBI::NodeWithComments < ::RBI::Node
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#95
   sig { params(loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#101
   sig { returns(T::Array[::String]) }
   def annotations; end
 
-  # source://rbi//lib/rbi/model.rb#92
   sig { returns(T::Array[::RBI::Comment]) }
   def comments; end
 
   # @return [Array<Comment>]
-  #
-  # source://rbi//lib/rbi/model.rb#92
   def comments=(_arg0); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#311
   sig { override.params(other: ::RBI::Node).void }
   def merge_with(other); end
 
-  # source://rbi//lib/rbi/rewriters/filter_versions.rb#104
   sig { returns(T::Array[::Gem::Requirement]) }
   def version_requirements; end
 end
 
-# source://rbi//lib/rbi/model.rb#676
 class RBI::OptParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#691
   sig do
     params(
       name: ::String,
@@ -1194,196 +934,147 @@ class RBI::OptParam < ::RBI::Param
   end
   def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#698
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#680
   sig { returns(::String) }
   def value; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#627
 class RBI::Param < ::RBI::NodeWithComments
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#643
   sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#634
   sig { returns(::String) }
   def name; end
 
-  # source://rbi//lib/rbi/model.rb#649
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/parser.rb#7
 class RBI::ParseError < ::RBI::Error
-  # source://rbi//lib/rbi/parser.rb#14
   sig { params(message: ::String, location: ::RBI::Loc).void }
   def initialize(message, location); end
 
-  # source://rbi//lib/rbi/parser.rb#11
   sig { returns(::RBI::Loc) }
   def location; end
 end
 
-# source://rbi//lib/rbi/parser.rb#53
 class RBI::Parser
-  # source://rbi//lib/rbi/parser.rb#88
   sig { params(path: ::String).returns(::RBI::Tree) }
   def parse_file(path); end
 
-  # source://rbi//lib/rbi/parser.rb#83
   sig { params(string: ::String).returns(::RBI::Tree) }
   def parse_string(string); end
 
   private
 
-  # source://rbi//lib/rbi/parser.rb#95
   sig { params(source: ::String, file: ::String).returns(::RBI::Tree) }
   def parse(source, file:); end
 
   class << self
-    # source://rbi//lib/rbi/parser.rb#65
     sig { params(path: ::String).returns(::RBI::Tree) }
     def parse_file(path); end
 
-    # source://rbi//lib/rbi/parser.rb#70
     sig { params(paths: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
     def parse_files(paths); end
 
-    # source://rbi//lib/rbi/parser.rb#60
     sig { params(string: ::String).returns(::RBI::Tree) }
     def parse_string(string); end
 
-    # source://rbi//lib/rbi/parser.rb#76
     sig { params(strings: T::Array[::String]).returns(T::Array[::RBI::Tree]) }
     def parse_strings(strings); end
   end
 end
 
-# source://rbi//lib/rbi/parser.rb#791
 class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor
-  # source://rbi//lib/rbi/parser.rb#798
   sig { params(content: ::String, file: ::String).void }
   def initialize(content, file:); end
 
-  # source://rbi//lib/rbi/parser.rb#795
   sig { returns(::RBI::Sig) }
   def current; end
 
-  # source://rbi//lib/rbi/parser.rb#850
   sig { override.params(node: ::Prism::AssocNode).void }
   def visit_assoc_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#805
   sig { override.params(node: ::Prism::CallNode).void }
   def visit_call_node(node); end
 end
 
-# source://rbi//lib/rbi/parser.rb#153
 class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor
-  # source://rbi//lib/rbi/parser.rb#163
   sig { params(source: ::String, comments: T::Array[::Prism::Comment], file: ::String).void }
   def initialize(source, comments:, file:); end
 
-  # source://rbi//lib/rbi/parser.rb#160
   sig { returns(T.nilable(::Prism::Node)) }
   def last_node; end
 
-  # source://rbi//lib/rbi/parser.rb#157
   sig { returns(::RBI::Tree) }
   def tree; end
 
-  # source://rbi//lib/rbi/parser.rb#299
   sig { params(node: ::Prism::CallNode).void }
   def visit_call_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#176
   sig { override.params(node: ::Prism::ClassNode).void }
   def visit_class_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#208
   sig { params(node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)).void }
   def visit_constant_assign(node); end
 
-  # source://rbi//lib/rbi/parser.rb#201
   sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
   def visit_constant_path_write_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#194
   sig { override.params(node: ::Prism::ConstantWriteNode).void }
   def visit_constant_write_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#241
   sig { override.params(node: ::Prism::DefNode).void }
   def visit_def_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#255
   sig { override.params(node: ::Prism::ModuleNode).void }
   def visit_module_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#272
   sig { override.params(node: ::Prism::ProgramNode).void }
   def visit_program_node(node); end
 
-  # source://rbi//lib/rbi/parser.rb#283
   sig { override.params(node: ::Prism::SingletonClassNode).void }
   def visit_singleton_class_node(node); end
 
   private
 
   # Collect all the remaining comments within a node
-  #
-  # source://rbi//lib/rbi/parser.rb#467
   sig { params(node: ::Prism::Node).void }
   def collect_dangling_comments(node); end
 
   # Collect all the remaining comments after visiting the tree
-  #
-  # source://rbi//lib/rbi/parser.rb#485
   sig { void }
   def collect_orphan_comments; end
 
-  # source://rbi//lib/rbi/parser.rb#508
   sig { returns(::RBI::Tree) }
   def current_scope; end
 
-  # source://rbi//lib/rbi/parser.rb#513
   sig { returns(T::Array[::RBI::Sig]) }
   def current_sigs; end
 
-  # source://rbi//lib/rbi/parser.rb#520
-  sig { returns(T::Array[::RBI::Comment]) }
-  def current_sigs_comments; end
+  sig { params(sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
+  def detach_comments_from_sigs(sigs); end
 
-  # source://rbi//lib/rbi/parser.rb#527
   sig { params(node: ::Prism::Node).returns(T::Array[::RBI::Comment]) }
   def node_comments(node); end
 
-  # source://rbi//lib/rbi/parser.rb#545
   sig { params(node: ::Prism::Comment).returns(::RBI::Comment) }
   def parse_comment(node); end
 
-  # source://rbi//lib/rbi/parser.rb#574
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Param]) }
   def parse_params(node); end
 
-  # source://rbi//lib/rbi/parser.rb#550
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Arg]) }
   def parse_send_args(node); end
 
-  # source://rbi//lib/rbi/parser.rb#648
   sig { params(node: ::Prism::CallNode).returns(::RBI::Sig) }
   def parse_sig(node); end
 
-  # source://rbi//lib/rbi/parser.rb#658
   sig do
     params(
       node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)
@@ -1391,51 +1082,39 @@ class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor
   end
   def parse_struct(node); end
 
-  # source://rbi//lib/rbi/parser.rb#708
   sig { params(send: ::Prism::CallNode).void }
   def parse_tstruct_field(send); end
 
-  # source://rbi//lib/rbi/parser.rb#745
   sig { params(name: ::String, node: ::Prism::Node).returns(::RBI::Visibility) }
   def parse_visibility(name, node); end
 
-  # source://rbi//lib/rbi/parser.rb#759
   sig { void }
   def separate_header_comments; end
 
-  # source://rbi//lib/rbi/parser.rb#769
   sig { void }
   def set_root_tree_loc; end
 
-  # source://rbi//lib/rbi/parser.rb#783
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
   def type_variable_definition?(node); end
 end
 
-# source://rbi//lib/rbi/parser.rb#122
 class RBI::Parser::Visitor < ::Prism::Visitor
-  # source://rbi//lib/rbi/parser.rb#126
   sig { params(source: ::String, file: ::String).void }
   def initialize(source, file:); end
 
   private
 
-  # source://rbi//lib/rbi/parser.rb#136
   sig { params(node: ::Prism::Node).returns(::RBI::Loc) }
   def node_loc(node); end
 
-  # source://rbi//lib/rbi/parser.rb#141
   sig { params(node: T.nilable(::Prism::Node)).returns(T.nilable(::String)) }
   def node_string(node); end
 
-  # source://rbi//lib/rbi/parser.rb#148
   sig { params(node: ::Prism::Node).returns(::String) }
   def node_string!(node); end
 end
 
-# source://rbi//lib/rbi/printer.rb#7
 class RBI::Printer < ::RBI::Visitor
-  # source://rbi//lib/rbi/printer.rb#30
   sig do
     params(
       out: T.any(::IO, ::StringIO),
@@ -1446,316 +1125,233 @@ class RBI::Printer < ::RBI::Visitor
   end
   def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/printer.rb#17
   sig { returns(::Integer) }
   def current_indent; end
 
-  # source://rbi//lib/rbi/printer.rb#48
   sig { void }
   def dedent; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/printer.rb#11
   def in_visibility_group; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/printer.rb#11
   def in_visibility_group=(_arg0); end
 
   # Printing
-  #
-  # source://rbi//lib/rbi/printer.rb#43
   sig { void }
   def indent; end
 
-  # source://rbi//lib/rbi/printer.rb#20
   sig { returns(T.nilable(::Integer)) }
   def max_line_length; end
 
-  # source://rbi//lib/rbi/printer.rb#14
   sig { returns(T.nilable(::RBI::Node)) }
   def previous_node; end
 
   # Print a string without indentation nor `\n` at the end.
-  #
-  # source://rbi//lib/rbi/printer.rb#54
   sig { params(string: ::String).void }
   def print(string); end
 
-  # source://rbi//lib/rbi/printer.rb#11
   sig { returns(T::Boolean) }
   def print_locs; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/printer.rb#11
   def print_locs=(_arg0); end
 
   # Print a string with indentation and `\n` at the end.
-  #
-  # source://rbi//lib/rbi/printer.rb#74
   sig { params(string: ::String).void }
   def printl(string); end
 
   # Print a string without indentation but with a `\n` at the end.
-  #
-  # source://rbi//lib/rbi/printer.rb#60
   sig { params(string: T.nilable(::String)).void }
   def printn(string = T.unsafe(nil)); end
 
   # Print a string with indentation but without a `\n` at the end.
-  #
-  # source://rbi//lib/rbi/printer.rb#67
   sig { params(string: T.nilable(::String)).void }
   def printt(string = T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/printer.rb#80
   sig { override.params(nodes: T::Array[::RBI::Node]).void }
   def visit_all(nodes); end
 
-  # source://rbi//lib/rbi/printer.rb#91
   sig { override.params(file: ::RBI::File).void }
   def visit_file(file); end
 
   private
 
-  # source://rbi//lib/rbi/printer.rb#619
   sig { params(node: ::RBI::Node).returns(T::Boolean) }
   def oneline?(node); end
 
-  # source://rbi//lib/rbi/printer.rb#577
   sig { params(node: ::RBI::Node).void }
   def print_blank_line_before(node); end
 
-  # source://rbi//lib/rbi/printer.rb#587
   sig { params(node: ::RBI::Node).void }
   def print_loc(node); end
 
-  # source://rbi//lib/rbi/printer.rb#593
   sig { params(node: ::RBI::Param, last: T::Boolean).void }
   def print_param_comment_leading_space(node, last:); end
 
-  # source://rbi//lib/rbi/printer.rb#666
   sig { params(node: ::RBI::Sig).void }
   def print_sig_as_block(node); end
 
-  # source://rbi//lib/rbi/printer.rb#641
   sig { params(node: ::RBI::Sig).void }
   def print_sig_as_line(node); end
 
-  # source://rbi//lib/rbi/printer.rb#611
   sig { params(node: ::RBI::SigParam, last: T::Boolean).void }
   def print_sig_param_comment_leading_space(node, last:); end
 
-  # source://rbi//lib/rbi/printer.rb#722
   sig { params(node: ::RBI::Sig).returns(T::Array[::String]) }
   def sig_modifiers(node); end
 
-  # source://rbi//lib/rbi/printer.rb#417
   sig { override.params(node: ::RBI::Arg).void }
   def visit_arg(node); end
 
-  # source://rbi//lib/rbi/printer.rb#237
   sig { params(node: ::RBI::Attr).void }
   def visit_attr(node); end
 
-  # source://rbi//lib/rbi/printer.rb#222
   sig { override.params(node: ::RBI::AttrAccessor).void }
   def visit_attr_accessor(node); end
 
-  # source://rbi//lib/rbi/printer.rb#227
   sig { override.params(node: ::RBI::AttrReader).void }
   def visit_attr_reader(node); end
 
-  # source://rbi//lib/rbi/printer.rb#232
   sig { override.params(node: ::RBI::AttrWriter).void }
   def visit_attr_writer(node); end
 
-  # source://rbi//lib/rbi/printer.rb#126
   sig { override.params(node: ::RBI::BlankLine).void }
   def visit_blank_line(node); end
 
-  # source://rbi//lib/rbi/printer.rb#344
   sig { override.params(node: ::RBI::BlockParam).void }
   def visit_block_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#143
   sig { override.params(node: ::RBI::Class).void }
   def visit_class(node); end
 
-  # source://rbi//lib/rbi/printer.rb#110
   sig { override.params(node: ::RBI::Comment).void }
   def visit_comment(node); end
 
-  # source://rbi//lib/rbi/printer.rb#554
   sig { override.params(node: ::RBI::ConflictTree).void }
   def visit_conflict_tree(node); end
 
-  # source://rbi//lib/rbi/printer.rb#213
   sig { override.params(node: ::RBI::Const).void }
   def visit_const(node); end
 
-  # source://rbi//lib/rbi/printer.rb#354
   sig { override.params(node: ::RBI::Extend).void }
   def visit_extend(node); end
 
-  # source://rbi//lib/rbi/printer.rb#526
   sig { override.params(node: ::RBI::Group).void }
   def visit_group(node); end
 
-  # source://rbi//lib/rbi/printer.rb#512
   sig { override.params(node: ::RBI::Helper).void }
   def visit_helper(node); end
 
-  # source://rbi//lib/rbi/printer.rb#349
   sig { override.params(node: ::RBI::Include).void }
   def visit_include(node); end
 
-  # source://rbi//lib/rbi/printer.rb#422
   sig { override.params(node: ::RBI::KwArg).void }
   def visit_kw_arg(node); end
 
-  # source://rbi//lib/rbi/printer.rb#334
   sig { override.params(node: ::RBI::KwOptParam).void }
   def visit_kw_opt_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#329
   sig { override.params(node: ::RBI::KwParam).void }
   def visit_kw_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#339
   sig { override.params(node: ::RBI::KwRestParam).void }
   def visit_kw_rest_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#265
   sig { override.params(node: ::RBI::Method).void }
   def visit_method(node); end
 
-  # source://rbi//lib/rbi/printer.rb#521
   sig { override.params(node: ::RBI::MixesInClassMethods).void }
   def visit_mixes_in_class_methods(node); end
 
-  # source://rbi//lib/rbi/printer.rb#359
   sig { params(node: ::RBI::Mixin).void }
   def visit_mixin(node); end
 
-  # source://rbi//lib/rbi/printer.rb#138
   sig { override.params(node: ::RBI::Module).void }
   def visit_module(node); end
 
-  # source://rbi//lib/rbi/printer.rb#319
   sig { override.params(node: ::RBI::OptParam).void }
   def visit_opt_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#386
   sig { override.params(node: ::RBI::Private).void }
   def visit_private(node); end
 
-  # source://rbi//lib/rbi/printer.rb#381
   sig { override.params(node: ::RBI::Protected).void }
   def visit_protected(node); end
 
-  # source://rbi//lib/rbi/printer.rb#376
   sig { override.params(node: ::RBI::Public).void }
   def visit_public(node); end
 
-  # source://rbi//lib/rbi/printer.rb#314
   sig { override.params(node: ::RBI::ReqParam).void }
   def visit_req_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#545
   sig { override.params(node: ::RBI::RequiresAncestor).void }
   def visit_requires_ancestor(node); end
 
-  # source://rbi//lib/rbi/printer.rb#324
   sig { override.params(node: ::RBI::RestParam).void }
   def visit_rest_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#158
   sig { params(node: ::RBI::Scope).void }
   def visit_scope(node); end
 
-  # source://rbi//lib/rbi/printer.rb#203
   sig { params(node: ::RBI::Scope).void }
   def visit_scope_body(node); end
 
-  # source://rbi//lib/rbi/printer.rb#563
   sig { override.params(node: ::RBI::ScopeConflict).void }
   def visit_scope_conflict(node); end
 
-  # source://rbi//lib/rbi/printer.rb#168
   sig { params(node: ::RBI::Scope).void }
   def visit_scope_header(node); end
 
-  # source://rbi//lib/rbi/printer.rb#400
   sig { override.params(node: ::RBI::Send).void }
   def visit_send(node); end
 
-  # source://rbi//lib/rbi/printer.rb#427
   sig { override.params(node: ::RBI::Sig).void }
   def visit_sig(node); end
 
-  # source://rbi//lib/rbi/printer.rb#446
   sig { override.params(node: ::RBI::SigParam).void }
   def visit_sig_param(node); end
 
-  # source://rbi//lib/rbi/printer.rb#153
   sig { override.params(node: ::RBI::SingletonClass).void }
   def visit_singleton_class(node); end
 
-  # source://rbi//lib/rbi/printer.rb#148
   sig { override.params(node: ::RBI::Struct).void }
   def visit_struct(node); end
 
-  # source://rbi//lib/rbi/printer.rb#466
   sig { params(node: ::RBI::TStructField).void }
   def visit_t_struct_field(node); end
 
-  # source://rbi//lib/rbi/printer.rb#484
   sig { override.params(node: ::RBI::TEnum).void }
   def visit_tenum(node); end
 
-  # source://rbi//lib/rbi/printer.rb#489
   sig { override.params(node: ::RBI::TEnumBlock).void }
   def visit_tenum_block(node); end
 
-  # source://rbi//lib/rbi/printer.rb#131
   sig { override.params(node: ::RBI::Tree).void }
   def visit_tree(node); end
 
-  # source://rbi//lib/rbi/printer.rb#451
   sig { override.params(node: ::RBI::TStruct).void }
   def visit_tstruct(node); end
 
-  # source://rbi//lib/rbi/printer.rb#456
   sig { override.params(node: ::RBI::TStructConst).void }
   def visit_tstruct_const(node); end
 
-  # source://rbi//lib/rbi/printer.rb#461
   sig { override.params(node: ::RBI::TStructProp).void }
   def visit_tstruct_prop(node); end
 
-  # source://rbi//lib/rbi/printer.rb#503
   sig { override.params(node: ::RBI::TypeMember).void }
   def visit_type_member(node); end
 
-  # source://rbi//lib/rbi/printer.rb#391
   sig { params(node: ::RBI::Visibility).void }
   def visit_visibility(node); end
 
-  # source://rbi//lib/rbi/printer.rb#532
   sig { override.params(node: ::RBI::VisibilityGroup).void }
   def visit_visibility_group(node); end
 end
 
-# source://rbi//lib/rbi/printer.rb#5
 class RBI::PrinterError < ::RBI::Error; end
 
-# source://rbi//lib/rbi/model.rb#984
 class RBI::Private < ::RBI::Visibility
-  # source://rbi//lib/rbi/model.rb#994
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -1766,9 +1362,7 @@ class RBI::Private < ::RBI::Visibility
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 end
 
-# source://rbi//lib/rbi/model.rb#968
 class RBI::Protected < ::RBI::Visibility
-  # source://rbi//lib/rbi/model.rb#978
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -1779,9 +1373,7 @@ class RBI::Protected < ::RBI::Visibility
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 end
 
-# source://rbi//lib/rbi/model.rb#952
 class RBI::Public < ::RBI::Visibility
-  # source://rbi//lib/rbi/model.rb#962
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -1792,12 +1384,9 @@ class RBI::Public < ::RBI::Visibility
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 end
 
-# source://rbi//lib/rbi/model.rb#5
 class RBI::ReplaceNodeError < ::RBI::Error; end
 
-# source://rbi//lib/rbi/model.rb#654
 class RBI::ReqParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#665
   sig do
     params(
       name: ::String,
@@ -1808,35 +1397,27 @@ class RBI::ReqParam < ::RBI::Param
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#671
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 end
 
-# source://rbi//lib/rbi/model.rb#1458
 class RBI::RequiresAncestor < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1471
   sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/index.rb#163
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1462
   sig { returns(::String) }
   def name; end
 
-  # source://rbi//lib/rbi/model.rb#1477
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#703
 class RBI::RestParam < ::RBI::Param
-  # source://rbi//lib/rbi/model.rb#714
   sig do
     params(
       name: ::String,
@@ -1847,92 +1428,70 @@ class RBI::RestParam < ::RBI::Param
   end
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#725
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#720
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/rewriters/add_sig_templates.rb#5
 module RBI::Rewriters; end
 
-# source://rbi//lib/rbi/rewriters/add_sig_templates.rb#6
 class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#10
   sig { params(with_todo_comment: T::Boolean).void }
   def initialize(with_todo_comment: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#16
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#30
   sig { params(attr: ::RBI::Attr).void }
   def add_attr_sig(attr); end
 
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#45
   sig { params(method: ::RBI::Method).void }
   def add_method_sig(method); end
 
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#56
   sig { params(node: ::RBI::NodeWithComments).void }
   def add_todo_comment(node); end
 end
 
-# source://rbi//lib/rbi/rewriters/annotate.rb#6
 class RBI::Rewriters::Annotate < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/annotate.rb#10
   sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
   def initialize(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/annotate.rb#18
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/annotate.rb#31
   sig { params(node: ::RBI::NodeWithComments).void }
   def annotate_node(node); end
 
-  # source://rbi//lib/rbi/rewriters/annotate.rb#38
   sig { params(node: ::RBI::Node).returns(T::Boolean) }
   def root?(node); end
 end
 
-# source://rbi//lib/rbi/rewriters/attr_to_methods.rb#22
 class RBI::Rewriters::AttrToMethods < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#26
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
   # @raise [ReplaceNodeError]
-  #
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#39
   sig { params(node: ::RBI::Node, with: T::Array[::RBI::Node]).void }
   def replace(node, with:); end
 end
 
-# source://rbi//lib/rbi/rewriters/deannotate.rb#6
 class RBI::Rewriters::Deannotate < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/deannotate.rb#10
   sig { params(annotation: ::String).void }
   def initialize(annotation); end
 
-  # source://rbi//lib/rbi/rewriters/deannotate.rb#16
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/deannotate.rb#27
   sig { params(node: ::RBI::NodeWithComments).void }
   def deannotate_node(node); end
 end
@@ -1988,36 +1547,85 @@ end
 #
 # RBI with no versions:
 # - RBI with no version annotations are automatically counted towards ALL versions
-#
-# source://rbi//lib/rbi/rewriters/filter_versions.rb#57
 class RBI::Rewriters::FilterVersions < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/filter_versions.rb#73
   sig { params(version: ::Gem::Version).void }
   def initialize(version); end
 
-  # source://rbi//lib/rbi/rewriters/filter_versions.rb#79
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   class << self
-    # source://rbi//lib/rbi/rewriters/filter_versions.rb#66
     sig { params(tree: ::RBI::Tree, version: ::Gem::Version).void }
     def filter(tree, version); end
   end
 end
 
-# source://rbi//lib/rbi/rewriters/filter_versions.rb#60
 RBI::Rewriters::FilterVersions::VERSION_PREFIX = T.let(T.unsafe(nil), String)
 
-# source://rbi//lib/rbi/rewriters/group_nodes.rb#8
+# Rewrite non-singleton methods inside singleton classes to singleton methods
+#
+# Example:
+# ~~~rb
+# class << self
+#  def m1; end
+#  def self.m2; end
+#
+#  class << self
+#    def m3; end
+#  end
+# end
+# ~~~
+#
+# will be rewritten to:
+#
+# ~~~rb
+# def self.m1; end
+#
+# class << self
+#   def self.m2; end
+#   def self.m3; end
+# end
+# ~~~
+class RBI::Rewriters::FlattenSingletonMethods < ::RBI::Visitor
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# Flattens visibility nodes into method nodes
+#
+# Example:
+# ~~~rb
+# class A
+#   def m1; end
+#   private
+#   def m2; end
+#   def m3; end
+# end
+# ~~~
+#
+# will be transformed into:
+#
+# ~~~rb
+# class A
+#   def m1; end
+#   private def m2; end
+#   private def m3; end
+# end
+# ~~~
+class RBI::Rewriters::FlattenVisibilities < ::RBI::Visitor
+  sig { void }
+  def initialize; end
+
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
 class RBI::Rewriters::GroupNodes < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/group_nodes.rb#12
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/group_nodes.rb#36
   sig { params(node: ::RBI::Node).returns(::RBI::Group::Kind) }
   def group_kind(node); end
 end
@@ -2055,23 +1663,17 @@ end
 #   C = 10
 # end
 # ~~~
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#39
 class RBI::Rewriters::Merge
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#70
   sig { params(left_name: ::String, right_name: ::String, keep: ::RBI::Rewriters::Merge::Keep).void }
   def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#79
   sig { params(tree: ::RBI::Tree).void }
   def merge(tree); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#67
   sig { returns(::RBI::MergeTree) }
   def tree; end
 
   class << self
-    # source://rbi//lib/rbi/rewriters/merge_trees.rb#54
     sig do
       params(
         left: ::RBI::Tree,
@@ -2086,20 +1688,16 @@ class RBI::Rewriters::Merge
 end
 
 # Used for logging / error displaying purpose
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#86
 class RBI::Rewriters::Merge::Conflict < ::T::Struct
   const :left, ::RBI::Node
   const :right, ::RBI::Node
   const :left_name, ::String
   const :right_name, ::String
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#95
   sig { returns(::String) }
   def to_s; end
 
   class << self
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
@@ -2134,36 +1732,28 @@ end
 #   >>>>>>> right
 # end
 # ~~~
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#245
 class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#247
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#252
   sig { override.params(nodes: T::Array[::RBI::Node]).void }
   def visit_all(nodes); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#273
   sig { params(left: ::RBI::Tree, right: ::RBI::Tree).void }
   def merge_conflict_trees(left, right); end
 end
 
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#42
 class RBI::Rewriters::Merge::Keep < ::T::Enum
   enums do
-    NONE = new
     LEFT = new
+    NONE = new
     RIGHT = new
   end
 end
 
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#100
 class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#107
   sig do
     params(
       output: ::RBI::Tree,
@@ -2174,47 +1764,60 @@ class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
   end
   def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#104
   sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) }
   def conflicts; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#119
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#168
   sig { returns(::RBI::Tree) }
   def current_scope; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#185
   sig { params(left: ::RBI::Scope, right: ::RBI::Scope).void }
   def make_conflict_scope(left, right); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#192
   sig { params(left: ::RBI::Node, right: ::RBI::Node).void }
   def make_conflict_tree(left, right); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#173
   sig { params(node: ::RBI::Node).returns(T.nilable(::RBI::Node)) }
   def previous_definition(node); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#204
   sig { params(left: ::RBI::Scope, right: ::RBI::Scope).returns(::RBI::Scope) }
   def replace_scope_header(left, right); end
 end
 
-# source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#6
-class RBI::Rewriters::NestNonPublicMethods < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#10
+class RBI::Rewriters::NestNonPublicMembers < ::RBI::Visitor
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 end
 
-# source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#6
 class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#10
+  sig { override.params(node: T.nilable(::RBI::Node)).void }
+  def visit(node); end
+end
+
+# This rewriter moves top-level members into a top-level Object class
+#
+# Example:
+# ~~~rb
+# def foo; end
+# attr_reader :bar
+# ~~~
+#
+# will be rewritten to:
+#
+# ~~~rb
+# class Object
+#  def foo; end
+#  attr_reader :bar
+# end
+# ~~~
+class RBI::Rewriters::NestTopLevelMembers < ::RBI::Visitor
+  sig { void }
+  def initialize; end
+
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 end
@@ -2261,41 +1864,31 @@ end
 #   Deleted ::FOO at -:5:0-5:8 (duplicate from -:1:0-1:8)
 # OPERATIONS
 # ~~~
-#
-# source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#48
 class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#55
   sig { params(index: ::RBI::Index).void }
   def initialize(index); end
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#52
   sig { returns(T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]) }
   def operations; end
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#83
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#78
   sig { params(nodes: T::Array[::RBI::Node]).void }
   def visit_all(nodes); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#111
   sig { params(node: ::RBI::Node, previous: ::RBI::Node).returns(T::Boolean) }
   def can_delete_node?(node, previous); end
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#129
   sig { params(node: ::RBI::Node, previous: ::RBI::Node).void }
   def delete_node(node, previous); end
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#102
   sig { params(node: ::RBI::Indexable).returns(T.nilable(::RBI::Node)) }
   def previous_definition_for(node); end
 
   class << self
-    # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#70
     sig do
       params(
         tree: ::RBI::Tree,
@@ -2306,42 +1899,33 @@ class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor
   end
 end
 
-# source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#134
 class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct
   const :deleted_node, ::RBI::Node
   const :duplicate_of, ::RBI::Node
 
-  # source://rbi//lib/rbi/rewriters/remove_known_definitions.rb#141
   sig { returns(::String) }
   def to_s; end
 
   class << self
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
-# source://rbi//lib/rbi/rewriters/sort_nodes.rb#6
 class RBI::Rewriters::SortNodes < ::RBI::Visitor
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#10
   sig { override.params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
   private
 
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#73
   sig { params(kind: ::RBI::Group::Kind).returns(::Integer) }
   def group_rank(kind); end
 
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#94
   sig { params(node: ::RBI::Node).returns(T.nilable(::String)) }
   def node_name(node); end
 
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#45
   sig { params(node: ::RBI::Node).returns(::Integer) }
   def node_rank(node); end
 
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#106
   sig { params(node: ::RBI::Node).void }
   def sort_node_names!(node); end
 end
@@ -2349,30 +1933,22 @@ end
 # Scopes
 #
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#178
 class RBI::Scope < ::RBI::Tree
   include ::RBI::Indexable
 
   abstract!
 
   # Duplicate `self` scope without its body
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#358
   sig { returns(T.self_type) }
   def dup_empty; end
 
   # @abstract
-  #
-  # source://rbi//lib/rbi/model.rb#184
   sig { abstract.returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/index.rb#93
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#187
   sig { override.returns(::String) }
   def to_s; end
 end
@@ -2389,39 +1965,27 @@ end
 #   def m1; end
 # end
 # ~~~
-#
-# source://rbi//lib/rbi/rewriters/merge_trees.rb#624
 class RBI::ScopeConflict < ::RBI::Tree
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#641
   sig { params(left: ::RBI::Scope, right: ::RBI::Scope, left_name: ::String, right_name: ::String).void }
   def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#628
   sig { returns(::RBI::Scope) }
   def left; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#631
   sig { returns(::String) }
   def left_name; end
 
   # @return [Scope]
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#628
   def right; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#631
   def right_name; end
 end
 
 # Sends
-#
-# source://rbi//lib/rbi/model.rb#1002
 class RBI::Send < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1020
   sig do
     params(
       method: ::String,
@@ -2433,44 +1997,34 @@ class RBI::Send < ::RBI::NodeWithComments
   end
   def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#1028
   sig { params(arg: ::RBI::Arg).void }
   def <<(arg); end
 
-  # source://rbi//lib/rbi/model.rb#1033
   sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#1009
   sig { returns(T::Array[::RBI::Arg]) }
   def args; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#531
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/index.rb#193
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1006
   sig { returns(::String) }
   def method; end
 
-  # source://rbi//lib/rbi/model.rb#1038
   sig { returns(::String) }
   def to_s; end
 end
 
 # Sorbet's sigs
-#
-# source://rbi//lib/rbi/model.rb#1102
-class RBI::Sig < ::RBI::Node
-  # source://rbi//lib/rbi/model.rb#1134
+class RBI::Sig < ::RBI::NodeWithComments
   sig do
     params(
       params: T::Array[::RBI::SigParam],
-      return_type: T.nilable(::String),
+      return_type: T.any(::RBI::Type, ::String),
       is_abstract: T::Boolean,
       is_override: T::Boolean,
       is_overridable: T::Boolean,
@@ -2478,96 +2032,69 @@ class RBI::Sig < ::RBI::Node
       type_params: T::Array[::String],
       checked: T.nilable(::Symbol),
       loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
       block: T.nilable(T.proc.params(node: ::RBI::Sig).void)
     ).void
   end
-  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), &block); end
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#1159
   sig { params(param: ::RBI::SigParam).void }
   def <<(param); end
 
-  # source://rbi//lib/rbi/model.rb#1169
   sig { params(other: ::Object).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#1164
-  sig { params(name: ::String, type: ::String).void }
+  sig { params(name: ::String, type: T.any(::RBI::Type, ::String)).void }
   def add_param(name, type); end
 
-  # source://rbi//lib/rbi/model.rb#1118
   sig { returns(T.nilable(::Symbol)) }
   def checked; end
 
   # @return [Symbol, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#1118
   def checked=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#1112
   sig { returns(T::Boolean) }
   def is_abstract; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_abstract=(_arg0); end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_final; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_final=(_arg0); end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_overridable; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_overridable=(_arg0); end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_override; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#1112
   def is_override=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#1106
   sig { returns(T::Array[::RBI::SigParam]) }
   def params; end
 
-  # source://rbi//lib/rbi/model.rb#1109
-  sig { returns(T.nilable(::String)) }
+  sig { returns(T.any(::RBI::Type, ::String)) }
   def return_type; end
 
-  # @return [String, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#1109
+  # @return [Type, String]
   def return_type=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#1115
   sig { returns(T::Array[::String]) }
   def type_params; end
 end
 
-# source://rbi//lib/rbi/model.rb#1178
 class RBI::SigParam < ::RBI::NodeWithComments
-  # source://rbi//lib/rbi/model.rb#1193
   sig do
     params(
       name: ::String,
-      type: ::String,
+      type: T.any(::RBI::Type, ::String),
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment],
       block: T.nilable(T.proc.params(node: ::RBI::SigParam).void)
@@ -2575,23 +2102,17 @@ class RBI::SigParam < ::RBI::NodeWithComments
   end
   def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#1201
   sig { params(other: ::Object).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#1182
   sig { returns(::String) }
   def name; end
 
-  # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#1182
+  sig { returns(T.any(::RBI::Type, ::String)) }
   def type; end
 end
 
-# source://rbi//lib/rbi/model.rb#253
 class RBI::SingletonClass < ::RBI::Scope
-  # source://rbi//lib/rbi/model.rb#263
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -2601,14 +2122,11 @@ class RBI::SingletonClass < ::RBI::Scope
   end
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#269
   sig { override.returns(::String) }
   def fully_qualified_name; end
 end
 
-# source://rbi//lib/rbi/model.rb#274
 class RBI::Struct < ::RBI::Scope
-  # source://rbi//lib/rbi/model.rb#296
   sig do
     params(
       name: ::String,
@@ -2621,47 +2139,33 @@ class RBI::Struct < ::RBI::Scope
   end
   def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#396
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#305
   sig { override.returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/model.rb#284
   sig { returns(T::Boolean) }
   def keyword_init; end
 
   # @return [Boolean]
-  #
-  # source://rbi//lib/rbi/model.rb#284
   def keyword_init=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#281
   sig { returns(T::Array[::Symbol]) }
   def members; end
 
   # @return [Array<Symbol>]
-  #
-  # source://rbi//lib/rbi/model.rb#281
   def members=(_arg0); end
 
-  # source://rbi//lib/rbi/model.rb#278
   sig { returns(::String) }
   def name; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#278
   def name=(_arg0); end
 end
 
 # Sorbet's T::Enum
-#
-# source://rbi//lib/rbi/model.rb#1319
 class RBI::TEnum < ::RBI::Class
-  # source://rbi//lib/rbi/model.rb#1330
   sig do
     params(
       name: ::String,
@@ -2673,51 +2177,28 @@ class RBI::TEnum < ::RBI::Class
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 end
 
-# source://rbi//lib/rbi/model.rb#1336
-class RBI::TEnumBlock < ::RBI::NodeWithComments
-  include ::RBI::Indexable
-
-  # source://rbi//lib/rbi/model.rb#1350
+class RBI::TEnumBlock < ::RBI::Scope
   sig do
     params(
-      names: T::Array[::String],
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment],
       block: T.nilable(T.proc.params(node: ::RBI::TEnumBlock).void)
     ).void
   end
-  def initialize(names = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  # source://rbi//lib/rbi/model.rb#1362
-  sig { params(name: ::String).void }
-  def <<(name); end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#1357
-  sig { returns(T::Boolean) }
-  def empty?; end
+  sig { override.returns(::String) }
+  def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/index.rb#223
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#558
-  sig { override.params(other: ::RBI::Node).void }
-  def merge_with(other); end
-
-  # source://rbi//lib/rbi/model.rb#1340
-  sig { returns(T::Array[::String]) }
-  def names; end
-
-  # source://rbi//lib/rbi/model.rb#1367
   sig { override.returns(::String) }
   def to_s; end
 end
 
 # Sorbet's T::Struct
-#
-# source://rbi//lib/rbi/model.rb#1208
 class RBI::TStruct < ::RBI::Class
-  # source://rbi//lib/rbi/model.rb#1219
   sig do
     params(
       name: ::String,
@@ -2729,15 +2210,13 @@ class RBI::TStruct < ::RBI::Class
   def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 end
 
-# source://rbi//lib/rbi/model.rb#1257
 class RBI::TStructConst < ::RBI::TStructField
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1270
   sig do
     params(
       name: ::String,
-      type: ::String,
+      type: T.any(::RBI::Type, ::String),
       default: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment],
@@ -2746,34 +2225,27 @@ class RBI::TStructConst < ::RBI::TStructField
   end
   def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#549
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#1276
   sig { override.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/index.rb#203
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1282
   sig { override.returns(::String) }
   def to_s; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#1225
 class RBI::TStructField < ::RBI::NodeWithComments
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#1246
   sig do
     params(
       name: ::String,
-      type: ::String,
+      type: T.any(::RBI::Type, ::String),
       default: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment]
@@ -2781,54 +2253,39 @@ class RBI::TStructField < ::RBI::NodeWithComments
   end
   def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#540
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#1235
   sig { returns(T.nilable(::String)) }
   def default; end
 
   # @return [String, nil]
-  #
-  # source://rbi//lib/rbi/model.rb#1235
   def default=(_arg0); end
 
   # @abstract
-  #
-  # source://rbi//lib/rbi/model.rb#1254
   sig { abstract.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/model.rb#1232
   sig { returns(::String) }
   def name; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#1232
   def name=(_arg0); end
 
-  # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#1232
+  sig { returns(T.any(::RBI::Type, ::String)) }
   def type; end
 
-  # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#1232
+  # @return [Type, String]
   def type=(_arg0); end
 end
 
-# source://rbi//lib/rbi/model.rb#1287
 class RBI::TStructProp < ::RBI::TStructField
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1300
   sig do
     params(
       name: ::String,
-      type: ::String,
+      type: T.any(::RBI::Type, ::String),
       default: T.nilable(::String),
       loc: T.nilable(::RBI::Loc),
       comments: T::Array[::RBI::Comment],
@@ -2837,26 +2294,20 @@ class RBI::TStructProp < ::RBI::TStructField
   end
   def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#572
   sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
   def compatible_with?(other); end
 
-  # source://rbi//lib/rbi/model.rb#1306
   sig { override.returns(T::Array[::String]) }
   def fully_qualified_names; end
 
-  # source://rbi//lib/rbi/index.rb#213
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1312
   sig { override.returns(::String) }
   def to_s; end
 end
 
-# source://rbi//lib/rbi/model.rb#108
 class RBI::Tree < ::RBI::NodeWithComments
-  # source://rbi//lib/rbi/model.rb#121
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -2866,19 +2317,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#128
   sig { params(node: ::RBI::Node).void }
   def <<(node); end
 
-  # source://rbi//lib/rbi/rewriters/add_sig_templates.rb#66
   sig { params(with_todo_comment: T::Boolean).void }
   def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/annotate.rb#49
   sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
   def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#38
   sig do
     params(
       name: ::String,
@@ -2888,19 +2335,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_class(name, superclass_name: T.unsafe(nil), &block); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#45
   sig { params(name: ::String, value: ::String).void }
   def create_constant(name, value:); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#55
   sig { params(name: ::String).void }
   def create_extend(name); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#50
   sig { params(name: ::String).void }
   def create_include(name); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#90
   sig do
     params(
       name: ::String,
@@ -2914,19 +2357,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#60
   sig { params(name: ::String).void }
   def create_mixes_in_class_methods(name); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#25
   sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
   def create_module(name, &block); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#9
   sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
   def create_path(constant, &block); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#74
   sig do
     params(
       name: ::String,
@@ -2939,27 +2378,27 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/deannotate.rb#41
   sig { params(annotation: ::String).void }
   def deannotate!(annotation); end
 
-  # source://rbi//lib/rbi/model.rb#134
   sig { returns(T::Boolean) }
   def empty?; end
 
-  # source://rbi//lib/rbi/rewriters/filter_versions.rb#118
   sig { params(version: ::Gem::Version).void }
   def filter_versions!(version); end
 
-  # source://rbi//lib/rbi/rewriters/group_nodes.rb#81
+  sig { void }
+  def flatten_singleton_methods!; end
+
+  sig { void }
+  def flatten_visibilities!; end
+
   sig { void }
   def group_nodes!; end
 
-  # source://rbi//lib/rbi/index.rb#68
   sig { returns(::RBI::Index) }
   def index; end
 
-  # source://rbi//lib/rbi/rewriters/merge_trees.rb#324
   sig do
     params(
       other: ::RBI::Tree,
@@ -2970,42 +2409,552 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#46
   sig { void }
-  def nest_non_public_methods!; end
+  def nest_non_public_members!; end
 
-  # source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#36
   sig { void }
   def nest_singleton_methods!; end
 
-  # source://rbi//lib/rbi/model.rb#112
+  sig { void }
+  def nest_top_level_members!; end
+
   sig { returns(T::Array[::RBI::Node]) }
   def nodes; end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#53
   sig { void }
   def replace_attributes_with_methods!; end
 
-  # source://rbi//lib/rbi/rewriters/sort_nodes.rb#119
   sig { void }
   def sort_nodes!; end
 
   private
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#123
   sig { params(node: ::RBI::Node).returns(::RBI::Node) }
   def create_node(node); end
 
-  # source://tapioca/0.16.1/lib/tapioca/rbi_ext/model.rb#118
   sig { returns(T::Hash[::String, ::RBI::Node]) }
   def nodes_cache; end
 end
 
-# source://rbi//lib/rbi/model.rb#1400
+# The base class for all RBI types.
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+class RBI::Type
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  # @abstract
+  sig { abstract.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { params(other: ::BasicObject).returns(T::Boolean) }
+  def eql?(other); end
+
+  sig { override.returns(::Integer) }
+  def hash; end
+
+  # Returns a new type that is `nilable` if it is not already.
+  #
+  # If the type is already nilable, it returns itself.
+  # ```ruby
+  # type = RBI::Type.simple("String")
+  # type.to_rbi # => "String"
+  # type.nilable.to_rbi # => "T.nilable(String)"
+  # type.nilable.nilable.to_rbi # => "T.nilable(String)"
+  # ```
+  sig { returns(::RBI::Type) }
+  def nilable; end
+
+  # Returns whether the type is nilable.
+  sig { returns(T::Boolean) }
+  def nilable?; end
+
+  # Returns the non-nilable version of the type.
+  # If the type is already non-nilable, it returns itself.
+  # If the type is nilable, it returns the inner type.
+  #
+  # ```ruby
+  # type = RBI::Type.nilable(RBI::Type.simple("String"))
+  # type.to_rbi # => "T.nilable(String)"
+  # type.non_nilable.to_rbi # => "String"
+  # type.non_nilable.non_nilable.to_rbi # => "String"
+  # ```
+  sig { returns(::RBI::Type) }
+  def non_nilable; end
+
+  # @abstract
+  sig { abstract.returns(::String) }
+  def to_rbi; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+
+  class << self
+    # Builds a type that represents an intersection of multiple types like `T.all(String, Integer)`.
+    #
+    # Note that this method transforms types such as `T.all(String, String)` into `String`, so
+    # it may return something other than a `All`.
+    sig { params(type1: ::RBI::Type, type2: ::RBI::Type, types: ::RBI::Type).returns(::RBI::Type) }
+    def all(type1, type2, *types); end
+
+    # Builds a type that represents a union of multiple types like `T.any(String, Integer)`.
+    #
+    # Note that this method transforms types such as `T.any(String, NilClass)` into `T.nilable(String)`, so
+    # it may return something other than a `Any`.
+    sig { params(type1: ::RBI::Type, type2: ::RBI::Type, types: ::RBI::Type).returns(::RBI::Type) }
+    def any(type1, type2, *types); end
+
+    # Builds a type that represents `T.anything`.
+    sig { returns(::RBI::Type::Anything) }
+    def anything; end
+
+    # Builds a type that represents `T.attached_class`.
+    sig { returns(::RBI::Type::AttachedClass) }
+    def attached_class; end
+
+    # Builds a type that represents `T::Boolean`.
+    sig { returns(::RBI::Type::Boolean) }
+    def boolean; end
+
+    # Builds a type that represents the singleton class of another type like `T.class_of(Foo)`.
+    sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).returns(::RBI::Type::ClassOf) }
+    def class_of(type, type_parameter = T.unsafe(nil)); end
+
+    # Builds a type that represents a generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`.
+    sig { params(name: ::String, params: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Generic) }
+    def generic(name, *params); end
+
+    # Builds a type that represents a nilable of another type like `T.nilable(String)`.
+    #
+    # Note that this method transforms types such as `T.nilable(T.untyped)` into `T.untyped`, so
+    # it may return something other than a `RBI::Type::Nilable`.
+    sig { params(type: ::RBI::Type).returns(::RBI::Type) }
+    def nilable(type); end
+
+    # Builds a type that represents `T.noreturn`.
+    sig { returns(::RBI::Type::NoReturn) }
+    def noreturn; end
+
+    sig { params(node: ::Prism::Node).returns(::RBI::Type) }
+    def parse_node(node); end
+
+    # @raise [Error]
+    sig { params(string: ::String).returns(::RBI::Type) }
+    def parse_string(string); end
+
+    # Builds a type that represents a proc type like `T.proc.void`.
+    sig { returns(::RBI::Type::Proc) }
+    def proc; end
+
+    # Builds a type that represents `T.self_type`.
+    sig { returns(::RBI::Type::SelfType) }
+    def self_type; end
+
+    # Builds a type that represents a shape type like `{name: String, age: Integer}`.
+    sig { params(types: T::Hash[T.any(::String, ::Symbol), ::RBI::Type]).returns(::RBI::Type::Shape) }
+    def shape(types = T.unsafe(nil)); end
+
+    # Builds a simple type like `String` or `::Foo::Bar`.
+    #
+    # It raises a `NameError` if the name is not a valid Ruby class identifier.
+    #
+    # @raise [NameError]
+    sig { params(name: ::String).returns(::RBI::Type::Simple) }
+    def simple(name); end
+
+    # Builds a type that represents the class of another type like `T::Class[Foo]`.
+    sig { params(type: ::RBI::Type).returns(::RBI::Type::Class) }
+    def t_class(type); end
+
+    # Builds a type that represents a tuple type like `[String, Integer]`.
+    sig { params(types: T.any(::RBI::Type, T::Array[::RBI::Type])).returns(::RBI::Type::Tuple) }
+    def tuple(*types); end
+
+    # Builds a type that represents a type parameter like `T.type_parameter(:U)`.
+    sig { params(name: ::Symbol).returns(::RBI::Type::TypeParameter) }
+    def type_parameter(name); end
+
+    # Builds a type that represents `T.untyped`.
+    sig { returns(::RBI::Type::Untyped) }
+    def untyped; end
+
+    # Builds a type that represents `void`.
+    sig { returns(::RBI::Type::Void) }
+    def void; end
+
+    private
+
+    sig { params(node: ::Prism::CallNode).returns(T::Array[::Prism::Node]) }
+    def call_chain(node); end
+
+    sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) }
+    def check_arguments_at_least!(node, count); end
+
+    sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) }
+    def check_arguments_exactly!(node, count); end
+
+    # @raise [Error]
+    sig { params(node: ::Prism::CallNode).returns(::RBI::Type) }
+    def parse_call(node); end
+
+    sig { params(node: T.any(::Prism::ConstantPathNode, ::Prism::ConstantReadNode)).returns(::RBI::Type) }
+    def parse_constant(node); end
+
+    # @raise [Error]
+    sig { params(node: ::Prism::CallNode).returns(::RBI::Type) }
+    def parse_proc(node); end
+
+    sig { params(node: T.any(::Prism::HashNode, ::Prism::KeywordHashNode)).returns(::RBI::Type) }
+    def parse_shape(node); end
+
+    sig { params(node: ::Prism::ArrayNode).returns(::RBI::Type) }
+    def parse_tuple(node); end
+
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t?(node); end
+
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t_boolean?(node); end
+
+    sig { params(node: ::Prism::ConstantPathNode).returns(T::Boolean) }
+    def t_class?(node); end
+
+    sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+    def t_class_of?(node); end
+
+    sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+    def t_proc?(node); end
+
+    sig { params(name: ::String).returns(T::Boolean) }
+    def valid_identifier?(name); end
+  end
+end
+
+# A type that is intersection of multiple types like `T.all(String, Integer)`.
+class RBI::Type::All < ::RBI::Type::Composite
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A type that is union of multiple types like `T.any(String, Integer)`.
+class RBI::Type::Any < ::RBI::Type::Composite
+  sig { returns(T::Boolean) }
+  def nilable?; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.anything`.
+class RBI::Type::Anything < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.attached_class`.
+class RBI::Type::AttachedClass < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T::Boolean`.
+class RBI::Type::Boolean < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# The class of another type like `T::Class[Foo]`.
+class RBI::Type::Class < ::RBI::Type
+  sig { params(type: ::RBI::Type).void }
+  def initialize(type); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(::RBI::Type) }
+  def type; end
+end
+
+# The singleton class of another type like `T.class_of(Foo)`.
+class RBI::Type::ClassOf < ::RBI::Type
+  sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).void }
+  def initialize(type, type_parameter = T.unsafe(nil)); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(::RBI::Type::Simple) }
+  def type; end
+
+  sig { returns(T.nilable(::RBI::Type)) }
+  def type_parameter; end
+end
+
+# A type that is composed of multiple types like `T.all(String, Integer)`.
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+class RBI::Type::Composite < ::RBI::Type
+  abstract!
+
+  sig { params(types: T::Array[::RBI::Type]).void }
+  def initialize(types); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T::Array[::RBI::Type]) }
+  def types; end
+end
+
+class RBI::Type::Error < ::RBI::Error; end
+
+# A generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`.
+class RBI::Type::Generic < ::RBI::Type
+  sig { params(name: ::String, params: ::RBI::Type).void }
+  def initialize(name, *params); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { returns(T::Array[::RBI::Type]) }
+  def params; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A type that can be `nil` like `T.nilable(String)`.
+class RBI::Type::Nilable < ::RBI::Type
+  sig { params(type: ::RBI::Type).void }
+  def initialize(type); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(::RBI::Type) }
+  def type; end
+end
+
+# `T.noreturn`.
+class RBI::Type::NoReturn < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A proc type like `T.proc.void`.
+class RBI::Type::Proc < ::RBI::Type
+  sig { void }
+  def initialize; end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { params(type: T.untyped).returns(T.self_type) }
+  def bind(type); end
+
+  sig { params(params: ::RBI::Type).returns(T.self_type) }
+  def params(**params); end
+
+  sig { returns(T.nilable(::RBI::Type)) }
+  def proc_bind; end
+
+  sig { returns(T::Hash[::Symbol, ::RBI::Type]) }
+  def proc_params; end
+
+  sig { returns(::RBI::Type) }
+  def proc_returns; end
+
+  sig { params(type: T.untyped).returns(T.self_type) }
+  def returns(type); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(T.self_type) }
+  def void; end
+end
+
+# `T.self_type`.
+class RBI::Type::SelfType < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A shape type like `{name: String, age: Integer}`.
+class RBI::Type::Shape < ::RBI::Type
+  sig { params(types: T::Hash[T.any(::String, ::Symbol), ::RBI::Type]).void }
+  def initialize(types); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(T::Hash[T.any(::String, ::Symbol), ::RBI::Type]) }
+  def types; end
+end
+
+# A type that represents a simple class name like `String` or `Foo`.
+#
+# It can also be a qualified name like `::Foo` or `Foo::Bar`.
+class RBI::Type::Simple < ::RBI::Type
+  sig { params(name: ::String).void }
+  def initialize(name); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# A tuple type like `[String, Integer]`.
+class RBI::Type::Tuple < ::RBI::Type
+  sig { params(types: T::Array[::RBI::Type]).void }
+  def initialize(types); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+
+  sig { returns(T::Array[::RBI::Type]) }
+  def types; end
+end
+
+# A type parameter like `T.type_parameter(:U)`.
+class RBI::Type::TypeParameter < ::RBI::Type
+  sig { params(name: ::Symbol).void }
+  def initialize(name); end
+
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(::Symbol) }
+  def name; end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+# `T.untyped`.
+class RBI::Type::Untyped < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
+class RBI::Type::Visitor
+  sig { params(node: ::RBI::Type).void }
+  def visit(node); end
+
+  private
+
+  sig { params(type: ::RBI::Type::All).void }
+  def visit_all(type); end
+
+  sig { params(type: ::RBI::Type::Any).void }
+  def visit_any(type); end
+
+  sig { params(type: ::RBI::Type::Anything).void }
+  def visit_anything(type); end
+
+  sig { params(type: ::RBI::Type::AttachedClass).void }
+  def visit_attached_class(type); end
+
+  sig { params(type: ::RBI::Type::Boolean).void }
+  def visit_boolean(type); end
+
+  sig { params(type: ::RBI::Type::Class).void }
+  def visit_class(type); end
+
+  sig { params(type: ::RBI::Type::ClassOf).void }
+  def visit_class_of(type); end
+
+  sig { params(type: ::RBI::Type::Generic).void }
+  def visit_generic(type); end
+
+  sig { params(type: ::RBI::Type::Nilable).void }
+  def visit_nilable(type); end
+
+  sig { params(type: ::RBI::Type::NoReturn).void }
+  def visit_no_return(type); end
+
+  sig { params(type: ::RBI::Type::Proc).void }
+  def visit_proc(type); end
+
+  sig { params(type: ::RBI::Type::SelfType).void }
+  def visit_self_type(type); end
+
+  sig { params(type: ::RBI::Type::Shape).void }
+  def visit_shape(type); end
+
+  sig { params(type: ::RBI::Type::Simple).void }
+  def visit_simple(type); end
+
+  sig { params(type: ::RBI::Type::Tuple).void }
+  def visit_tuple(type); end
+
+  sig { params(type: ::RBI::Type::TypeParameter).void }
+  def visit_type_parameter(type); end
+
+  sig { params(type: ::RBI::Type::Untyped).void }
+  def visit_untyped(type); end
+
+  sig { params(type: ::RBI::Type::Void).void }
+  def visit_void(type); end
+end
+
+class RBI::Type::Visitor::Error < ::RBI::Error; end
+
+# `void`.
+class RBI::Type::Void < ::RBI::Type
+  sig { override.params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(::String) }
+  def to_rbi; end
+end
+
 class RBI::TypeMember < ::RBI::NodeWithComments
   include ::RBI::Indexable
 
-  # source://rbi//lib/rbi/model.rb#1415
   sig do
     params(
       name: ::String,
@@ -3017,289 +2966,216 @@ class RBI::TypeMember < ::RBI::NodeWithComments
   end
   def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi//lib/rbi/model.rb#1423
   sig { returns(::String) }
   def fully_qualified_name; end
 
-  # source://rbi//lib/rbi/index.rb#183
   sig { override.returns(T::Array[::String]) }
   def index_ids; end
 
-  # source://rbi//lib/rbi/model.rb#1404
   sig { returns(::String) }
   def name; end
 
-  # source://rbi//lib/rbi/model.rb#1430
   sig { override.returns(::String) }
   def to_s; end
 
   # @return [String]
-  #
-  # source://rbi//lib/rbi/model.rb#1404
   def value; end
 end
 
-# source://rbi//lib/rbi/rewriters/attr_to_methods.rb#5
 class RBI::UnexpectedMultipleSigsError < ::RBI::Error
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#10
   sig { params(node: ::RBI::Node).void }
   def initialize(node); end
 
-  # source://rbi//lib/rbi/rewriters/attr_to_methods.rb#7
   sig { returns(::RBI::Node) }
   def node; end
 end
 
-# source://rbi//lib/rbi/parser.rb#20
 class RBI::UnexpectedParserError < ::RBI::Error
-  # source://rbi//lib/rbi/parser.rb#27
   sig { params(parent_exception: ::Exception, last_location: ::RBI::Loc).void }
   def initialize(parent_exception, last_location); end
 
-  # source://rbi//lib/rbi/parser.rb#24
   sig { returns(::RBI::Loc) }
   def last_location; end
 
-  # source://rbi//lib/rbi/parser.rb#34
   sig { params(io: T.any(::IO, ::StringIO)).void }
   def print_debug(io: T.unsafe(nil)); end
 end
 
-# source://rbi//lib/rbi/version.rb#5
 RBI::VERSION = T.let(T.unsafe(nil), String)
 
 # Visibility
 #
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/model.rb#916
 class RBI::Visibility < ::RBI::NodeWithComments
   abstract!
 
-  # source://rbi//lib/rbi/model.rb#926
   sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void }
   def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
 
-  # source://rbi//lib/rbi/model.rb#932
-  sig { params(other: ::RBI::Visibility).returns(T::Boolean) }
+  sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
   def ==(other); end
 
-  # source://rbi//lib/rbi/model.rb#947
   sig { returns(T::Boolean) }
   def private?; end
 
-  # source://rbi//lib/rbi/model.rb#942
   sig { returns(T::Boolean) }
   def protected?; end
 
-  # source://rbi//lib/rbi/model.rb#937
   sig { returns(T::Boolean) }
   def public?; end
 
-  # source://rbi//lib/rbi/model.rb#923
   sig { returns(::Symbol) }
   def visibility; end
 end
 
-# source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#52
 class RBI::VisibilityGroup < ::RBI::Tree
-  # source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#59
   sig { params(visibility: ::RBI::Visibility).void }
   def initialize(visibility); end
 
-  # source://rbi//lib/rbi/rewriters/nest_non_public_methods.rb#56
   sig { returns(::RBI::Visibility) }
   def visibility; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://rbi//lib/rbi/visitor.rb#7
 class RBI::Visitor
   abstract!
 
-  # source://rbi//lib/rbi/visitor.rb#14
   sig { params(node: T.nilable(::RBI::Node)).void }
   def visit(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#108
   sig { params(nodes: T::Array[::RBI::Node]).void }
   def visit_all(nodes); end
 
-  # source://rbi//lib/rbi/visitor.rb#113
   sig { params(file: ::RBI::File).void }
   def visit_file(file); end
 
   private
 
-  # source://rbi//lib/rbi/visitor.rb#195
   sig { params(node: ::RBI::Arg).void }
   def visit_arg(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#144
   sig { params(node: ::RBI::AttrAccessor).void }
   def visit_attr_accessor(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#147
   sig { params(node: ::RBI::AttrReader).void }
   def visit_attr_reader(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#150
   sig { params(node: ::RBI::AttrWriter).void }
   def visit_attr_writer(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#123
   sig { params(node: ::RBI::BlankLine).void }
   def visit_blank_line(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#174
   sig { params(node: ::RBI::BlockParam).void }
   def visit_block_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#129
   sig { params(node: ::RBI::Class).void }
   def visit_class(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#120
   sig { params(node: ::RBI::Comment).void }
   def visit_comment(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#240
   sig { params(node: ::RBI::ConflictTree).void }
   def visit_conflict_tree(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#141
   sig { params(node: ::RBI::Const).void }
   def visit_const(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#180
   sig { params(node: ::RBI::Extend).void }
   def visit_extend(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#234
   sig { params(node: ::RBI::Group).void }
   def visit_group(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#222
   sig { params(node: ::RBI::Helper).void }
   def visit_helper(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#177
   sig { params(node: ::RBI::Include).void }
   def visit_include(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#198
   sig { params(node: ::RBI::KwArg).void }
   def visit_kw_arg(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#168
   sig { params(node: ::RBI::KwOptParam).void }
   def visit_kw_opt_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#165
   sig { params(node: ::RBI::KwParam).void }
   def visit_kw_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#171
   sig { params(node: ::RBI::KwRestParam).void }
   def visit_kw_rest_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#153
   sig { params(node: ::RBI::Method).void }
   def visit_method(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#228
   sig { params(node: ::RBI::MixesInClassMethods).void }
   def visit_mixes_in_class_methods(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#126
   sig { params(node: ::RBI::Module).void }
   def visit_module(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#159
   sig { params(node: ::RBI::OptParam).void }
   def visit_opt_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#189
   sig { params(node: ::RBI::Private).void }
   def visit_private(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#186
   sig { params(node: ::RBI::Protected).void }
   def visit_protected(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#183
   sig { params(node: ::RBI::Public).void }
   def visit_public(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#156
   sig { params(node: ::RBI::ReqParam).void }
   def visit_req_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#231
   sig { params(node: ::RBI::RequiresAncestor).void }
   def visit_requires_ancestor(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#162
   sig { params(node: ::RBI::RestParam).void }
   def visit_rest_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#243
   sig { params(node: ::RBI::ScopeConflict).void }
   def visit_scope_conflict(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#192
   sig { params(node: ::RBI::Send).void }
   def visit_send(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#201
   sig { params(node: ::RBI::Sig).void }
   def visit_sig(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#204
   sig { params(node: ::RBI::SigParam).void }
   def visit_sig_param(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#132
   sig { params(node: ::RBI::SingletonClass).void }
   def visit_singleton_class(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#135
   sig { params(node: ::RBI::Struct).void }
   def visit_struct(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#216
   sig { params(node: ::RBI::TEnum).void }
   def visit_tenum(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#219
   sig { params(node: ::RBI::TEnumBlock).void }
   def visit_tenum_block(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#138
   sig { params(node: ::RBI::Tree).void }
   def visit_tree(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#207
   sig { params(node: ::RBI::TStruct).void }
   def visit_tstruct(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#210
   sig { params(node: ::RBI::TStructConst).void }
   def visit_tstruct_const(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#213
   sig { params(node: ::RBI::TStructProp).void }
   def visit_tstruct_prop(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#225
   sig { params(node: ::RBI::TypeMember).void }
   def visit_type_member(node); end
 
-  # source://rbi//lib/rbi/visitor.rb#237
   sig { params(node: ::RBI::VisibilityGroup).void }
   def visit_visibility_group(node); end
 end
 
-# source://rbi//lib/rbi/visitor.rb#5
 class RBI::VisitorError < ::RBI::Error; end
diff --git a/sorbet/rbi/gems/tapioca@0.16.1.rbi b/sorbet/rbi/gems/tapioca@0.16.2.rbi
similarity index 66%
rename from sorbet/rbi/gems/tapioca@0.16.1.rbi
rename to sorbet/rbi/gems/tapioca@0.16.2.rbi
index 51bd6d3..361e331 100644
--- a/sorbet/rbi/gems/tapioca@0.16.1.rbi
+++ b/sorbet/rbi/gems/tapioca@0.16.2.rbi
@@ -9,20 +9,16 @@ class Bundler::Dependency < ::Gem::Dependency
   include ::Tapioca::BundlerExt::AutoRequireHook
 end
 
-# source://tapioca//lib/tapioca/helpers/git_attributes.rb#4
 class GitAttributes
   class << self
-    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#9
     sig { params(path: ::Pathname).void }
     def create_generated_attribute_file(path); end
 
-    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#16
     sig { params(path: ::Pathname).void }
     def create_vendored_attribute_file(path); end
 
     private
 
-    # source://tapioca//lib/tapioca/helpers/git_attributes.rb#25
     sig { params(path: ::Pathname, content: ::String).void }
     def create_gitattributes_file(path, content); end
   end
@@ -34,28 +30,16 @@ end
 # So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
 # That's because RubyGems does alias-method-chain for Kernel#require and such,
 # so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
-#
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#68
 class Module
-  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#101
   def append_features(constant); end
-
-  # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#71
   def autoload(const_name, path); end
-
-  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#111
   def extend_object(obj); end
-
-  # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#91
   def prepend_features(constant); end
 end
 
-# source://tapioca//lib/tapioca/rbi_ext/model.rb#4
 module RBI; end
 
-# source://tapioca//lib/tapioca/rbi_ext/model.rb#5
 class RBI::Tree < ::RBI::NodeWithComments
-  # source://rbi/0.1.14/lib/rbi/model.rb#121
   sig do
     params(
       loc: T.nilable(::RBI::Loc),
@@ -65,19 +49,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://rbi/0.1.14/lib/rbi/model.rb#128
   sig { params(node: ::RBI::Node).void }
   def <<(node); end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/add_sig_templates.rb#66
   sig { params(with_todo_comment: T::Boolean).void }
   def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/annotate.rb#49
   sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
   def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#38
   sig do
     params(
       name: ::String,
@@ -87,19 +67,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_class(name, superclass_name: T.unsafe(nil), &block); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#45
   sig { params(name: ::String, value: ::String).void }
   def create_constant(name, value:); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#55
   sig { params(name: ::String).void }
   def create_extend(name); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#50
   sig { params(name: ::String).void }
   def create_include(name); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#90
   sig do
     params(
       name: ::String,
@@ -113,19 +89,15 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#60
   sig { params(name: ::String).void }
   def create_mixes_in_class_methods(name); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#25
   sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
   def create_module(name, &block); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#9
   sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
   def create_path(constant, &block); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#74
   sig do
     params(
       name: ::String,
@@ -138,27 +110,27 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/deannotate.rb#41
   sig { params(annotation: ::String).void }
   def deannotate!(annotation); end
 
-  # source://rbi/0.1.14/lib/rbi/model.rb#134
   sig { returns(T::Boolean) }
   def empty?; end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/filter_versions.rb#118
   sig { params(version: ::Gem::Version).void }
   def filter_versions!(version); end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/group_nodes.rb#81
+  sig { void }
+  def flatten_singleton_methods!; end
+
+  sig { void }
+  def flatten_visibilities!; end
+
   sig { void }
   def group_nodes!; end
 
-  # source://rbi/0.1.14/lib/rbi/index.rb#68
   sig { returns(::RBI::Index) }
   def index; end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/merge_trees.rb#324
   sig do
     params(
       other: ::RBI::Tree,
@@ -169,62 +141,48 @@ class RBI::Tree < ::RBI::NodeWithComments
   end
   def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/nest_non_public_methods.rb#46
   sig { void }
-  def nest_non_public_methods!; end
+  def nest_non_public_members!; end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/nest_singleton_methods.rb#36
   sig { void }
   def nest_singleton_methods!; end
 
-  # source://rbi/0.1.14/lib/rbi/model.rb#112
+  sig { void }
+  def nest_top_level_members!; end
+
   sig { returns(T::Array[::RBI::Node]) }
   def nodes; end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/attr_to_methods.rb#53
   sig { void }
   def replace_attributes_with_methods!; end
 
-  # source://rbi/0.1.14/lib/rbi/rewriters/sort_nodes.rb#119
   sig { void }
   def sort_nodes!; end
 
   private
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#123
   sig { params(node: ::RBI::Node).returns(::RBI::Node) }
   def create_node(node); end
 
-  # source://tapioca//lib/tapioca/rbi_ext/model.rb#118
   sig { returns(T::Hash[::String, ::RBI::Node]) }
   def nodes_cache; end
 end
 
-# source://tapioca//lib/tapioca/rbi_ext/model.rb#133
 class RBI::TypedParam < ::T::Struct
   const :param, ::RBI::Param
   const :type, ::String
 
   class << self
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#5
 module T::Generic
   include ::Kernel
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13
   def [](*types); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#47
   def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21
   def type_member(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#34
   def type_template(variance = T.unsafe(nil), &bounds_proc); end
 end
 
@@ -234,26 +192,15 @@ end
 #
 # We are interested in the data of the `[]`, `type_member` and `type_template` calls which
 # are all needed to generate good generic information at runtime.
-#
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#12
 module T::Generic::TypeStoragePatch
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#13
   def [](*types); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#47
   def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#21
   def type_member(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#34
   def type_template(variance = T.unsafe(nil), &bounds_proc); end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#28
 module T::Private::Methods
   class << self
-    # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
     def finalize_proc(decl); end
   end
 end
@@ -312,70 +259,49 @@ class T::Private::Methods::DeclarationBlock < ::Struct
   end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#29
 module T::Private::Methods::ProcBindPatch
-  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
   def finalize_proc(decl); end
 end
 
 class T::Types::Proc < ::T::Types::Base; end
 
-# source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#6
 module T::Types::ProcBindPatch
-  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#7
   def initialize(arg_types, returns, bind = T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/proc_bind_patch.rb#15
   def name; end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#6
 class T::Types::Simple < ::T::Types::Base
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#70
   def name; end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#65
 module T::Types::Simple::GenericPatch
   # This method intercepts calls to the `name` method for simple types, so that
   # it can ask the name to the type if the type is generic, since, by this point,
   # we've created a clone of that type with the `name` method returning the
   # appropriate name for that specific concrete type.
-  #
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#70
   def name; end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#7
 module T::Types::Simple::NamePatch
-  # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#10
   def name; end
-
-  # source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#16
   def qualified_name_of(constant); end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/name_patch.rb#8
 T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#87
 module T::Utils::Private
   class << self
-    # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#89
     def coerce_and_check_module_types(val, check_val, check_module_type); end
   end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#88
 module T::Utils::Private::PrivateCoercePatch
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#89
   def coerce_and_check_module_types(val, check_val, check_module_type); end
 end
 
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#4
 module Tapioca
   class << self
-    # source://tapioca//lib/tapioca.rb#20
     sig do
       type_parameters(:Result)
         .params(
@@ -386,35 +312,25 @@ module Tapioca
   end
 end
 
-# source://tapioca//lib/tapioca.rb#39
 Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#5
 module Tapioca::BundlerExt; end
 
 # This is a module that gets prepended to `Bundler::Dependency` and
 # makes sure even gems marked as `require: false` are required during
 # `Bundler.require`.
-#
-# source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#9
 module Tapioca::BundlerExt::AutoRequireHook
   requires_ancestor { Bundler::Dependency }
 
-  # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#46
   sig { returns(T.untyped) }
   def autorequire; end
 
   class << self
     # @return [Boolean]
-    #
-    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#26
     def enabled?; end
 
-    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#22
     sig { params(name: T.untyped).returns(T::Boolean) }
     def excluded?(name); end
 
-    # source://tapioca//lib/tapioca/bundler_ext/auto_require_hook.rb#36
     sig do
       type_parameters(:Result)
         .params(
@@ -426,94 +342,61 @@ module Tapioca::BundlerExt::AutoRequireHook
   end
 end
 
-# source://tapioca//lib/tapioca.rb#62
 Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#61
 Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#60
 Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/cli.rb#5
 class Tapioca::Cli < ::Thor
   include ::Tapioca::CliHelper
   include ::Tapioca::ConfigHelper
   include ::Tapioca::EnvHelper
 
-  # source://tapioca//lib/tapioca/cli.rb#366
   def __print_version; end
-
-  # source://tapioca//lib/tapioca/cli.rb#348
   def annotations; end
-
-  # source://tapioca//lib/tapioca/cli.rb#320
   def check_shims; end
-
-  # source://tapioca//lib/tapioca/cli.rb#46
   def configure; end
-
-  # source://tapioca//lib/tapioca/cli.rb#147
   def dsl(*constant_or_paths); end
 
   # @raise [MalformattedArgumentError]
-  #
-  # source://tapioca//lib/tapioca/cli.rb#264
   def gem(*gems); end
 
-  # source://tapioca//lib/tapioca/cli.rb#27
   def init; end
-
-  # source://tapioca//lib/tapioca/cli.rb#57
   def require; end
-
-  # source://tapioca//lib/tapioca/cli.rb#74
   def todo; end
 
   private
 
-  # source://tapioca//lib/tapioca/cli.rb#380
   def print_init_next_steps; end
 
   class << self
-    # source://tapioca//lib/tapioca/cli.rb#372
     def exit_on_failure?; end
   end
 end
 
-# source://tapioca//lib/tapioca/cli.rb#10
 Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/helpers/cli_helper.rb#5
 module Tapioca::CliHelper
   requires_ancestor { Thor::Shell }
 
-  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#33
   sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
   def netrc_file(options); end
 
-  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#26
   sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
   def rbi_formatter(options); end
 
-  # source://tapioca//lib/tapioca/helpers/cli_helper.rb#12
   sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
   def say_error(message = T.unsafe(nil), *color); end
 end
 
-# source://tapioca//lib/tapioca/commands.rb#5
 module Tapioca::Commands; end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/commands/abstract_dsl.rb#6
 class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracker
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIFilesHelper
 
   abstract!
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#33
   sig do
     params(
       requested_constants: T::Array[::String],
@@ -539,15 +422,12 @@ class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracke
 
   private
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#100
   sig { returns(T::Array[::String]) }
   def all_requested_constants; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#293
   sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
   def build_error_for_files(cause, files); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#217
   sig do
     params(
       constant_name: ::String,
@@ -558,89 +438,68 @@ class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracke
   end
   def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#154
   sig { params(constant_names: T::Array[::String], ignore_missing: T::Boolean).returns(T::Array[::Module]) }
   def constantize(constant_names, ignore_missing: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#177
   sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
   def constantize_compilers(compiler_names); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#353
   sig { returns(T::Array[::String]) }
   def constants_from_requested_paths; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#123
   sig { returns(::Tapioca::Dsl::Pipeline) }
   def create_pipeline; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#256
   sig { params(constant_name: ::String).returns(::Pathname) }
   def dsl_rbi_filename(constant_name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#140
   sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
   def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#348
   sig { params(constant: ::String).returns(::String) }
   def generate_command_for(constant); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#76
   sig { params(outpath: ::Pathname, quiet: T::Boolean).returns(T::Set[::Pathname]) }
   def generate_dsl_rbi_files(outpath, quiet:); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#113
   sig { void }
   def load_application; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#235
   sig { params(dir: ::Pathname).void }
   def perform_dsl_verification(dir); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#108
   sig { returns(::Tapioca::Dsl::Pipeline) }
   def pipeline; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#244
   sig { params(files: T::Set[::Pathname]).void }
   def purge_stale_dsl_rbi_files(files); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#343
   sig { params(constant: ::String).returns(::String) }
   def rbi_filename_for(constant); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#324
   sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
   def rbi_files_in(path); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#302
   sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
   def report_diff_and_exit_if_out_of_date(diff, command); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#197
   sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
   def resolve(name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#331
   sig { params(class_name: ::String).returns(::String) }
   def underscore(class_name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#261
   sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
   def verify_dsl_rbi(tmp_dir:); end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/commands/abstract_gem.rb#6
 class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIFilesHelper
 
   abstract!
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#32
   sig do
     params(
       gem_names: T::Array[::String],
@@ -665,35 +524,27 @@ class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
 
   private
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#230
   sig { returns(T::Array[::String]) }
   def added_rbis; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#291
   sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
   def build_error_for_files(cause, files); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#110
   sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
   def compile_gem_rbi(gem); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#225
   sig { params(gem_name: ::String).returns(::Pathname) }
   def existing_rbi(gem_name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#273
   sig { returns(T::Hash[::String, ::String]) }
   def existing_rbis; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#237
   sig { params(gem_name: ::String).returns(::Pathname) }
   def expected_rbi(gem_name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#279
   sig { returns(T::Hash[::String, ::String]) }
   def expected_rbis; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#98
   sig do
     params(
       gem: ::Tapioca::Gemfile::GemSpec,
@@ -702,46 +553,35 @@ class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
   end
   def gem_dependencies(gem, dependencies = T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#242
   sig { params(gem_name: ::String).returns(T::Boolean) }
   def gem_rbi_exists?(gem_name); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#286
   sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
   def gem_rbi_filename(gem_name, version); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#77
   sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
   def gems_to_generate(gem_names); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#296
   sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
   def merge_with_exported_rbi(gem, file); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#267
   sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
   def move(old_filename, new_filename); end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#177
   sig { void }
   def perform_additions; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#150
   sig { void }
   def perform_removals; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#220
   sig { returns(T::Array[::String]) }
   def removed_rbis; end
 
-  # source://tapioca//lib/tapioca/commands/abstract_gem.rb#247
   sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
   def report_diff_and_exit_if_out_of_date(diff, command); end
 end
 
-# source://tapioca//lib/tapioca/commands/annotations.rb#6
 class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca//lib/tapioca/commands/annotations.rb#18
   sig do
     params(
       central_repo_root_uris: T::Array[::String],
@@ -755,81 +595,62 @@ class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracke
 
   private
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#197
   sig { params(name: ::String, content: ::String).returns(::String) }
   def add_header(name, content); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#217
   sig { params(name: ::String, content: ::String).returns(::String) }
   def apply_typed_override(name, content); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#39
   sig { override.void }
   def execute; end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#136
   sig { params(repo_uris: T::Array[::String], gem_info: ::Tapioca::GemInfo).void }
   def fetch_annotation(repo_uris, gem_info); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#113
   sig { params(project_gems: T::Array[::Tapioca::GemInfo]).returns(T::Array[::String]) }
   def fetch_annotations(project_gems); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#156
   sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
   def fetch_file(repo_uri, path); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#173
   sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
   def fetch_http_file(repo_uri, path); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#102
   sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(Tapioca::RepoIndex)) }
   def fetch_index(repo_uri, repo_number:); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#81
   sig { returns(T::Hash[::String, Tapioca::RepoIndex]) }
   def fetch_indexes; end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#165
   sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
   def fetch_local_file(repo_uri, path); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#229
   sig { params(gem_version: ::Gem::Version, content: ::String).returns(::String) }
   def filter_versions(gem_version, content); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#50
   sig { returns(T::Array[::Tapioca::GemInfo]) }
   def list_gemfile_gems; end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#237
   sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) }
   def merge_files(gem_name, contents); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#60
   sig { params(project_gems: T::Array[::Tapioca::GemInfo]).void }
   def remove_expired_annotations(project_gems); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#264
   sig { returns(T::Hash[::String, T.nilable(::String)]) }
   def repo_tokens; end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#292
   sig { params(path: ::String, repo_uri: ::String, message: ::String).void }
   def say_http_error(path, repo_uri, message:); end
 
-  # source://tapioca//lib/tapioca/commands/annotations.rb#276
   sig { params(repo_uri: ::String).returns(T.nilable(::String)) }
   def token_for(repo_uri); end
 end
 
-# source://tapioca//lib/tapioca/commands/check_shims.rb#6
 class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIFilesHelper
 
-  # source://tapioca//lib/tapioca/commands/check_shims.rb#22
   sig do
     params(
       gem_rbi_dir: ::String,
@@ -845,14 +666,11 @@ class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
 
   private
 
-  # source://tapioca//lib/tapioca/commands/check_shims.rb#44
   sig { override.void }
   def execute; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/commands/command.rb#6
 class Tapioca::Commands::Command
   include ::Thor::Base
   include ::Thor::Invocation
@@ -863,21 +681,17 @@ class Tapioca::Commands::Command
 
   abstract!
 
-  # source://tapioca//lib/tapioca/commands/command.rb#20
   sig { void }
   def initialize; end
 
-  # source://thor/1.3.1/lib/thor/base.rb#155
   sig { returns(::Thor::Actions) }
   def file_writer; end
 
-  # source://tapioca//lib/tapioca/commands/command.rb#25
   sig(:final) { void }
   def run; end
 
   private
 
-  # source://tapioca//lib/tapioca/commands/command.rb#53
   sig do
     params(
       path: T.any(::Pathname, ::String),
@@ -889,207 +703,159 @@ class Tapioca::Commands::Command
   end
   def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/commands/command.rb#37
   sig { params(command: ::Symbol, args: ::String).returns(::String) }
   def default_command(command, *args); end
 
   # @abstract
-  #
-  # source://tapioca//lib/tapioca/commands/command.rb#34
   sig { abstract.void }
   def execute; end
 
-  # source://tapioca//lib/tapioca/commands/command.rb#63
   sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
   def remove_file(path, verbose: T.unsafe(nil)); end
 end
 
-# source://tapioca//lib/tapioca/commands/command.rb#10
 class Tapioca::Commands::Command::FileWriter < ::Thor
   include ::Thor::Actions
   extend ::Thor::Actions::ClassMethods
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/commands/command_without_tracker.rb#6
 class Tapioca::Commands::CommandWithoutTracker < ::Tapioca::Commands::Command
   abstract!
 
-  # source://tapioca//lib/tapioca/commands/command_without_tracker.rb#12
   sig { void }
   def initialize; end
 end
 
-# source://tapioca//lib/tapioca/commands/configure.rb#6
 class Tapioca::Commands::Configure < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca//lib/tapioca/commands/configure.rb#14
   sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
   def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end
 
   private
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#79
   sig { void }
   def create_binstub; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#69
   sig { void }
   def create_post_require; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#40
   sig { void }
   def create_sorbet_config; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#50
   sig { void }
   def create_tapioca_config; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#32
   sig { override.void }
   def execute; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#92
   sig { returns(::Bundler::Installer) }
   def installer; end
 
-  # source://tapioca//lib/tapioca/commands/configure.rb#97
   sig { returns(T.any(::Bundler::StubSpecification, ::Gem::Specification)) }
   def spec; end
 end
 
-# source://tapioca//lib/tapioca/commands/dsl_compiler_list.rb#6
 class Tapioca::Commands::DslCompilerList < ::Tapioca::Commands::AbstractDsl
   private
 
-  # source://tapioca//lib/tapioca/commands/dsl_compiler_list.rb#10
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/dsl_generate.rb#6
 class Tapioca::Commands::DslGenerate < ::Tapioca::Commands::AbstractDsl
   private
 
-  # source://tapioca//lib/tapioca/commands/dsl_generate.rb#10
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/dsl_verify.rb#6
 class Tapioca::Commands::DslVerify < ::Tapioca::Commands::AbstractDsl
   private
 
-  # source://tapioca//lib/tapioca/commands/dsl_verify.rb#10
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/gem_generate.rb#6
 class Tapioca::Commands::GemGenerate < ::Tapioca::Commands::AbstractGem
   private
 
-  # source://tapioca//lib/tapioca/commands/gem_generate.rb#10
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/gem_sync.rb#6
 class Tapioca::Commands::GemSync < ::Tapioca::Commands::AbstractGem
   private
 
-  # source://tapioca//lib/tapioca/commands/gem_sync.rb#10
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/gem_verify.rb#6
 class Tapioca::Commands::GemVerify < ::Tapioca::Commands::AbstractGem
   private
 
-  # source://tapioca//lib/tapioca/commands/gem_verify.rb#10
   sig { override.void }
   def execute; end
 
-  # source://tapioca//lib/tapioca/commands/gem_verify.rb#17
   sig { void }
   def perform_sync_verification; end
 end
 
-# source://tapioca//lib/tapioca/commands/require.rb#6
 class Tapioca::Commands::Require < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca//lib/tapioca/commands/require.rb#13
   sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
   def initialize(requires_path:, sorbet_config_path:); end
 
   private
 
-  # source://tapioca//lib/tapioca/commands/require.rb#23
   sig { override.void }
   def execute; end
 end
 
-# source://tapioca//lib/tapioca/commands/todo.rb#6
 class Tapioca::Commands::Todo < ::Tapioca::Commands::CommandWithoutTracker
   include ::Tapioca::SorbetHelper
 
-  # source://tapioca//lib/tapioca/commands/todo.rb#26
   sig { params(todo_file: ::String, file_header: T::Boolean).void }
   def initialize(todo_file:, file_header:); end
 
-  # source://tapioca//lib/tapioca/commands/todo.rb#34
   sig { void }
   def run_with_deprecation; end
 
   private
 
-  # source://tapioca//lib/tapioca/commands/todo.rb#44
   sig { override.void }
   def execute; end
 
-  # source://tapioca//lib/tapioca/commands/todo.rb#68
   sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
   def rbi(constants, command:); end
 
-  # source://tapioca//lib/tapioca/commands/todo.rb#88
   sig { returns(T::Array[::String]) }
   def unresolved_constants; end
 end
 
-# source://tapioca//lib/tapioca/commands/todo.rb#9
 Tapioca::Commands::Todo::DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/helpers/config_helper.rb#5
 module Tapioca::ConfigHelper
   requires_ancestor { Thor }
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#18
   sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
   def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#12
   sig { returns(::String) }
   def command_name; end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#15
   sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
   def defaults; end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#34
   sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
   def options; end
 
   private
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#153
   sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
   def build_error(msg); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#178
   sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) }
   def build_error_message(config_file, errors); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#56
   sig do
     params(
       options: ::Thor::CoreExt::HashWithIndifferentAccess
@@ -1097,11 +863,9 @@ module Tapioca::ConfigHelper
   end
   def config_options(options); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#46
   sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
   def filter_defaults(options); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#196
   sig do
     params(
       options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
@@ -1109,11 +873,9 @@ module Tapioca::ConfigHelper
   end
   def merge_options(*options); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#70
   sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
   def validate_config!(config_file, config); end
 
-  # source://tapioca//lib/tapioca/helpers/config_helper.rb#102
   sig do
     params(
       command_options: T::Hash[::Symbol, ::Thor::Option],
@@ -1124,66 +886,37 @@ module Tapioca::ConfigHelper
   def validate_config_options(command_options, config_key, config_options); end
 end
 
-# source://tapioca//lib/tapioca/helpers/config_helper.rb#148
 class Tapioca::ConfigHelper::ConfigError < ::T::Struct
   const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
 
   class << self
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
-# source://tapioca//lib/tapioca/helpers/config_helper.rb#143
 class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
   const :message, ::String
   const :colors, T::Array[::Symbol]
 
   class << self
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
-# source://tapioca//lib/tapioca.rb#46
 Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#42
 Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#58
 Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#43
 Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#48
 Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
-
-# source://tapioca//lib/tapioca.rb#40
 Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#41
 Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/rbi_formatter.rb#31
 Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
-
-# source://tapioca//lib/tapioca.rb#57
 Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
-
-# source://tapioca//lib/tapioca.rb#44
 Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#45
 Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/dsl/compilers.rb#5
 module Tapioca::Dsl; end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/dsl/compiler.rb#6
 class Tapioca::Dsl::Compiler
   extend T::Generic
   include ::Tapioca::SorbetHelper
@@ -1197,7 +930,6 @@ class Tapioca::Dsl::Compiler
 
   ConstantType = type_member { { upper: Module } }
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#74
   sig do
     params(
       pipeline: ::Tapioca::Dsl::Pipeline,
@@ -1209,81 +941,61 @@ class Tapioca::Dsl::Compiler
   def initialize(pipeline, root, constant, options = T.unsafe(nil)); end
 
   # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
-  #
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#92
   sig { params(error: ::String).void }
   def add_error(error); end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#83
   sig { params(compiler_name: ::String).returns(T::Boolean) }
   def compiler_enabled?(compiler_name); end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#20
   sig { returns(ConstantType) }
   def constant; end
 
   # @abstract
-  #
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#88
   sig { abstract.void }
   def decorate; end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#26
   sig { returns(T::Hash[::String, T.untyped]) }
   def options; end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#23
   sig { returns(::RBI::Tree) }
   def root; end
 
   private
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#141
   sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
   def compile_method_parameters_to_rbi(method_def); end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#177
   sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
   def compile_method_return_type_to_rbi(method_def); end
 
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#131
   sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
   def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end
 
   # Get the types of each parameter from a method signature
-  #
-  # source://tapioca//lib/tapioca/dsl/compiler.rb#105
   sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
   def parameters_types_from_signature(method_def, signature); end
 
   class << self
     # @abstract
-    #
-    # source://tapioca//lib/tapioca/dsl/compiler.rb#37
     sig { abstract.returns(T::Enumerable[::Module]) }
     def gather_constants; end
 
-    # source://tapioca//lib/tapioca/dsl/compiler.rb#32
     sig { params(constant: ::Module).returns(T::Boolean) }
     def handles?(constant); end
 
-    # source://tapioca//lib/tapioca/dsl/compiler.rb#40
     sig { returns(T::Set[::Module]) }
     def processable_constants; end
 
     private
 
-    # source://tapioca//lib/tapioca/dsl/compiler.rb#50
     sig { returns(T::Enumerable[T::Class[T.anything]]) }
     def all_classes; end
 
-    # source://tapioca//lib/tapioca/dsl/compiler.rb#58
     sig { returns(T::Enumerable[::Module]) }
     def all_modules; end
   end
 end
 
-# source://tapioca//lib/tapioca/dsl/compilers.rb#6
 module Tapioca::Dsl::Compilers; end
 
 # DSL compilers are either built-in to Tapioca and live under the
@@ -1292,13 +1004,9 @@ module Tapioca::Dsl::Compilers; end
 # a different namespace and can only be referred to using their fully
 # qualified name. This constant encapsulates that dual lookup when
 # a compiler needs to be resolved by name.
-#
-# source://tapioca//lib/tapioca/dsl/compilers.rb#13
 Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)
 
-# source://tapioca//lib/tapioca/dsl/pipeline.rb#6
 class Tapioca::Dsl::Pipeline
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#39
   sig do
     params(
       requested_constants: T::Array[::Module],
@@ -1313,39 +1021,30 @@ class Tapioca::Dsl::Pipeline
   end
   def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil), compiler_options: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#10
   sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
   def active_compilers; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#102
   sig { params(error: ::String).void }
   def add_error(error); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#107
   sig { params(compiler_name: ::String).returns(T::Boolean) }
   def compiler_enabled?(compiler_name); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#116
   sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
   def compilers; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#22
   sig { returns(T.proc.params(error: ::String).void) }
   def error_handler; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#25
   sig { returns(T::Array[::String]) }
   def errors; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#13
   sig { returns(T::Array[::Module]) }
   def requested_constants; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#16
   sig { returns(T::Array[::Pathname]) }
   def requested_paths; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#67
   sig do
     type_parameters(:T)
       .params(
@@ -1354,21 +1053,17 @@ class Tapioca::Dsl::Pipeline
   end
   def run(&blk); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#19
   sig { returns(T::Array[::Module]) }
   def skipped_constants; end
 
   private
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#223
   sig { void }
   def abort_if_pending_migrations!; end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#168
   sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) }
   def filter_anonymous_and_reloaded_constants(constants); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#133
   sig do
     params(
       requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
@@ -1377,7 +1072,6 @@ class Tapioca::Dsl::Pipeline
   end
   def gather_active_compilers(requested_compilers, excluded_compilers); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#147
   sig do
     params(
       requested_constants: T::Array[::Module],
@@ -1387,33 +1081,26 @@ class Tapioca::Dsl::Pipeline
   end
   def gather_constants(requested_constants, requested_paths, skipped_constants); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#197
   sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
   def rbi_for_constant(constant); end
 
-  # source://tapioca//lib/tapioca/dsl/pipeline.rb#216
   sig { params(error: ::String).returns(T.noreturn) }
   def report_error(error); end
 end
 
-# source://tapioca//lib/tapioca/helpers/env_helper.rb#5
 module Tapioca::EnvHelper
   requires_ancestor { Thor }
 
-  # source://tapioca//lib/tapioca/helpers/env_helper.rb#12
   sig { params(options: T::Hash[::Symbol, T.untyped]).void }
   def set_environment(options); end
 end
 
 class Tapioca::Error < ::StandardError; end
 
-# source://tapioca//lib/tapioca/executor.rb#5
 class Tapioca::Executor
-  # source://tapioca//lib/tapioca/executor.rb#11
   sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
   def initialize(queue, number_of_workers: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/executor.rb#28
   sig do
     type_parameters(:T)
       .params(
@@ -1424,137 +1111,102 @@ class Tapioca::Executor
 
   private
 
-  # source://tapioca//lib/tapioca/executor.rb#37
   sig { returns(::Integer) }
   def max_processors; end
 end
 
-# source://tapioca//lib/tapioca/executor.rb#8
 Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
-
-# source://tapioca//lib/tapioca/gem/events.rb#5
 module Tapioca::Gem; end
 
-# source://tapioca//lib/tapioca/gem/events.rb#77
 class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca//lib/tapioca/gem/events.rb#84
   sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
   def initialize(symbol, constant, node); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#81
   sig { returns(::RBI::Const) }
   def node; end
 end
 
-# source://tapioca//lib/tapioca/gem/events.rb#26
 class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
-  # source://tapioca//lib/tapioca/gem/events.rb#36
   sig { params(symbol: ::String, constant: ::BasicObject).void }
   def initialize(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#33
   sig { returns(::BasicObject) }
   def constant; end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#30
   sig { returns(::String) }
   def symbol; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/gem/events.rb#6
 class Tapioca::Gem::Event
   abstract!
 end
 
-# source://tapioca//lib/tapioca/gem/events.rb#43
 class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound
-  # source://tapioca//lib/tapioca/gem/events.rb#52
   sig { params(symbol: ::String, constant: ::Module).void }
   def initialize(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#47
   sig { override.returns(::Module) }
   def constant; end
 end
 
-# source://tapioca//lib/tapioca/gem/events.rb#103
 class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end
-
-# source://tapioca//lib/tapioca/gem/listeners/base.rb#6
 module Tapioca::Gem::Listeners; end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/gem/listeners/base.rb#7
 class Tapioca::Gem::Listeners::Base
   abstract!
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#14
   sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
   def initialize(pipeline); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#19
   sig { params(event: ::Tapioca::Gem::NodeAdded).void }
   def dispatch(event); end
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#49
   sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#37
   sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
   def on_const(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#45
   sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
   def on_method(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/base.rb#41
   sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#7
 class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#31
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/dynamic_mixins.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#7
 class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#60
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#55
   sig { params(location: ::String).returns(T::Boolean) }
   def mixed_in_by_gem?(location); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/foreign_constants.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/methods.rb#7
 class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIHelper
@@ -1563,7 +1215,6 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#35
   sig do
     params(
       tree: ::RBI::Tree,
@@ -1575,7 +1226,6 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
   end
   def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#71
   sig do
     params(
       tree: ::RBI::Tree,
@@ -1587,23 +1237,18 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
   end
   def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#211
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#204
   sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) }
   def initialize_method_for(constant); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#216
   sig { params(method: ::UnboundMethod).returns(T.untyped) }
   def lookup_signature_of(method); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#172
   sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
   def method_names_by_visibility(mod); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#196
   sig { params(attached_class: T.nilable(::Module), method_name: ::Symbol).returns(T.nilable(T::Boolean)) }
   def method_new_in_abstract_class?(attached_class, method_name); end
 
@@ -1616,28 +1261,22 @@ class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
   # This method implements a better way of checking whether a constant defines a method.
   # It walks up the ancestor tree via the `super_method` method; if any of the super
   # methods are owned by the constant, it means that the constant declares the method.
-  #
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#158
   sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) }
   def method_owned_by_constant?(method, constant); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#16
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/methods.rb#181
   sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) }
   def struct_method?(constant, method_name); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/mixins.rb#7
 class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#42
   sig do
     params(
       tree: ::RBI::Tree,
@@ -1648,15 +1287,12 @@ class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
   end
   def add_mixins(tree, constant, mods, mixin_type); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#84
   sig { params(mixin_name: ::String).returns(T::Boolean) }
   def filtered_mixin?(mixin_name); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#91
   sig { params(constant: ::Module).returns(T::Array[::Module]) }
   def interesting_ancestors_of(constant); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#75
   sig do
     params(
       constant: ::Module,
@@ -1666,86 +1302,69 @@ class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
   end
   def mixed_in_by_gem?(constant, mixin, mixin_type); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/mixins.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#7
 class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#20
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#7
 class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#25
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_enums.rb#13
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#7
 class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#27
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_helpers.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#7
 class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIHelper
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#33
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#14
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#7
 class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#23
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#13
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#7
 class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
@@ -1754,125 +1373,95 @@ class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Bas
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#26
   sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
   def compile_signature(signature, parameters); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#79
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#18
   sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
   def on_method(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#68
   sig { params(signature: T.untyped).returns(T::Boolean) }
   def signature_final?(signature); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_signatures.rb#13
 Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
 
-# source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#7
 class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#27
   sig { params(tree: ::RBI::Tree, constant: ::Module).void }
   def compile_type_variable_declarations(tree, constant); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#63
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#50
   sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) }
   def node_from_type_variable(type_variable); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/sorbet_type_variables.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/source_location.rb#7
 class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#41
   sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void }
   def add_source_location_comment(node, file, line); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#13
   sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
   def on_const(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#35
   sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
   def on_method(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/source_location.rb#19
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#7
 class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#36
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/subconstants.rb#15
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#7
 class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#27
   sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
   def initialize(pipeline); end
 
   private
 
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#55
   sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
   def documentation_comments(name, sigs: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#99
   sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
   def ignore?(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#36
   sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
   def on_const(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#46
   sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
   def on_method(event); end
 
-  # source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#41
   sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
   def on_scope(event); end
 end
 
-# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#10
 Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca//lib/tapioca/gem/listeners/yard_doc.rb#24
 Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array)
 
-# source://tapioca//lib/tapioca/gem/events.rb#105
 class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca//lib/tapioca/gem/events.rb#130
   sig do
     params(
       symbol: ::String,
@@ -1885,50 +1474,39 @@ class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
   end
   def initialize(symbol, constant, method, node, signature, parameters); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#109
   sig { returns(::UnboundMethod) }
   def method; end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#112
   sig { returns(::RBI::Method) }
   def node; end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#118
   sig { returns(T::Array[[::Symbol, ::String]]) }
   def parameters; end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#115
   sig { returns(T.untyped) }
   def signature; end
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/gem/events.rb#57
 class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
   abstract!
 
-  # source://tapioca//lib/tapioca/gem/events.rb#70
   sig { params(symbol: ::String, constant: ::Module).void }
   def initialize(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#67
   sig { returns(::Module) }
   def constant; end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#64
   sig { returns(::String) }
   def symbol; end
 end
 
-# source://tapioca//lib/tapioca/gem/pipeline.rb#6
 class Tapioca::Gem::Pipeline
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
   include ::Tapioca::SorbetHelper
   include ::Tapioca::RBIHelper
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#27
   sig do
     params(
       gem: ::Tapioca::Gemfile::GemSpec,
@@ -1939,49 +1517,37 @@ class Tapioca::Gem::Pipeline
   end
   def initialize(gem, error_handler:, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#64
   sig { returns(::RBI::Tree) }
   def compile; end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#135
   sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
   def constant_in_gem?(name); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#17
   sig { returns(T.proc.params(error: ::String).void) }
   def error_handler; end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#14
   sig { returns(::Tapioca::Gemfile::GemSpec) }
   def gem; end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#153
   sig { params(method: ::UnboundMethod).returns(T::Boolean) }
   def method_in_gem?(method); end
 
   # Helpers
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#163
   sig { params(constant: ::Module).returns(T.nilable(::String)) }
   def name_of(constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#87
   sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
   def push_const(symbol, constant, node); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#77
   sig { params(symbol: ::String, constant: ::BasicObject).void }
   def push_constant(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#82
   sig { params(symbol: ::String, constant: ::Module).void }
   def push_foreign_constant(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#101
   sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
   def push_foreign_scope(symbol, constant, node); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#115
   sig do
     params(
       symbol: ::String,
@@ -1994,137 +1560,101 @@ class Tapioca::Gem::Pipeline
   end
   def push_method(symbol, constant, method, node, signature, parameters); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#94
   sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
   def push_scope(symbol, constant, node); end
 
   # Events handling
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#72
   sig { params(symbol: ::String).void }
   def push_symbol(symbol); end
 
   # Constants and properties filtering
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#122
   sig { params(symbol_name: ::String).returns(T::Boolean) }
   def symbol_in_payload?(symbol_name); end
 
   private
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#456
   sig { params(name: ::String).void }
   def add_to_alias_namespace(name); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#461
   sig { params(name: ::String).returns(T::Boolean) }
   def alias_namespaced?(name); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#260
   sig { params(name: ::String, constant: ::Module).void }
   def compile_alias(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#246
   sig { params(symbol: ::String, constant: ::BasicObject).void }
   def compile_constant(symbol, constant); end
 
   # Compiling
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#235
   sig { params(symbol: ::String, constant: ::Module).void }
   def compile_foreign_constant(symbol, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#314
   sig { params(name: ::String, constant: ::Module).void }
   def compile_module(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#281
   sig { params(name: ::String, value: ::BasicObject).void }
   def compile_object(name, value); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#325
   sig { params(name: ::String, constant: ::Module).returns(::RBI::Scope) }
   def compile_scope(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#339
   sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
   def compile_superclass(constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#437
   sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) }
   def defined_in_gem?(constant, strict: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#193
   sig { params(event: ::Tapioca::Gem::Event).void }
   def dispatch(event); end
 
   # Helpers
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#480
   sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
   def generic_name_of(constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#449
   sig { params(constant: ::Module).returns(T::Set[::String]) }
   def get_file_candidates(constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#178
   sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
   def load_bootstrap_symbols(gem); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#496
   sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) }
   def name_of_proxy_target(constant, class_name); end
 
   # Events handling
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#188
   sig { returns(::Tapioca::Gem::Event) }
   def next_event; end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#216
   sig { params(event: ::Tapioca::Gem::ConstantFound).void }
   def on_constant(event); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#228
   sig { params(event: ::Tapioca::Gem::NodeAdded).void }
   def on_node(event); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#207
   sig { params(event: ::Tapioca::Gem::SymbolFound).void }
   def on_symbol(event); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#468
   sig { params(name: ::String).void }
   def seen!(name); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#473
   sig { params(name: ::String).returns(T::Boolean) }
   def seen?(name); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#407
   sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
   def skip_alias?(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#395
   sig { params(name: ::String, constant: T.anything).returns(T::Boolean) }
   def skip_constant?(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#424
   sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
   def skip_foreign_constant?(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#429
   sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
   def skip_module?(name, constant); end
 
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#416
   sig { params(name: ::String, constant: ::BasicObject).returns(T::Boolean) }
   def skip_object?(name, constant); end
 
   # Constants and properties filtering
-  #
-  # source://tapioca//lib/tapioca/gem/pipeline.rb#390
   sig { params(name: ::String).returns(T::Boolean) }
   def skip_symbol?(name); end
 end
@@ -2132,250 +1662,183 @@ end
 # this looks something like:
 # "(eval at /path/to/file.rb:123)"
 # and we are just interested in the "/path/to/file.rb" part
-#
-# source://tapioca//lib/tapioca/gem/pipeline.rb#132
 Tapioca::Gem::Pipeline::EVAL_SOURCE_FILE_PATTERN = T.let(T.unsafe(nil), Regexp)
 
-# source://tapioca//lib/tapioca/gem/pipeline.rb#11
 Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
 
-# source://tapioca//lib/tapioca/gem/events.rb#90
 class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca//lib/tapioca/gem/events.rb#97
   sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
   def initialize(symbol, constant, node); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#94
   sig { returns(::RBI::Scope) }
   def node; end
 end
 
-# source://tapioca//lib/tapioca/gem/events.rb#13
 class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
-  # source://tapioca//lib/tapioca/gem/events.rb#20
   sig { params(symbol: ::String).void }
   def initialize(symbol); end
 
-  # source://tapioca//lib/tapioca/gem/events.rb#17
   sig { returns(::String) }
   def symbol; end
 end
 
-# source://tapioca//lib/tapioca/helpers/gem_helper.rb#5
 module Tapioca::GemHelper
-  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#9
   sig { params(app_dir: T.any(::Pathname, ::String), full_gem_path: ::String).returns(T::Boolean) }
   def gem_in_app_dir?(app_dir, full_gem_path); end
 
-  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#17
   sig { params(full_gem_path: ::String).returns(T::Boolean) }
   def gem_in_bundle_path?(full_gem_path); end
 
-  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#22
   sig { params(full_gem_path: ::String).returns(T::Boolean) }
   def gem_in_ruby_path?(full_gem_path); end
 
-  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#27
   sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
   def to_realpath(path); end
 
   private
 
-  # source://tapioca//lib/tapioca/helpers/gem_helper.rb#36
   sig { params(path: T.any(::Pathname, ::String), dir: T.any(::Pathname, ::String)).returns(T::Boolean) }
   def path_in_dir?(path, dir); end
 end
 
-# source://tapioca//lib/tapioca/gem_info.rb#5
 class Tapioca::GemInfo < ::T::Struct
   const :name, ::String
   const :version, ::Gem::Version
 
   class << self
-    # source://tapioca//lib/tapioca/gem_info.rb#13
     sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
     def from_spec(spec); end
 
-    # source://sorbet-runtime/0.5.11528/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
-# source://tapioca//lib/tapioca/gemfile.rb#7
 class Tapioca::Gemfile
-  # source://tapioca//lib/tapioca/gemfile.rb#27
   sig { params(excluded_gems: T::Array[::String]).void }
   def initialize(excluded_gems); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#18
   sig { returns(::Bundler::Definition) }
   def definition; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#21
   sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
   def dependencies; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#40
   sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
   def gem(gem_name); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#24
   sig { returns(T::Array[::String]) }
   def missing_specs; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#45
   sig { void }
   def require_bundle; end
 
   private
 
-  # source://tapioca//lib/tapioca/gemfile.rb#92
   sig { returns(::String) }
   def dir; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#54
   sig { returns(::File) }
   def gemfile; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#87
   sig { returns(T::Array[::Symbol]) }
   def groups; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#57
   sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
   def load_dependencies; end
 
   # @return [File]
-  #
-  # source://tapioca//lib/tapioca/gemfile.rb#54
   def lockfile; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#68
   sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
   def materialize_deps; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#82
   sig { returns(::Bundler::Runtime) }
   def runtime; end
 end
 
-# source://tapioca//lib/tapioca/gemfile.rb#96
 class Tapioca::Gemfile::GemSpec
   include ::Tapioca::GemHelper
 
-  # source://tapioca//lib/tapioca/gemfile.rb#136
   sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
   def initialize(spec); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#146
   sig { params(other: ::BasicObject).returns(T::Boolean) }
   def ==(other); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#171
   sig { params(path: ::String).returns(T::Boolean) }
   def contains_path?(path); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#161
   sig { returns(T::Array[::Gem::Dependency]) }
   def dependencies; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#201
   sig { returns(T::Boolean) }
   def export_rbi_files?; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#196
   sig { returns(T::Array[::String]) }
   def exported_rbi_files; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#206
   sig { returns(::RBI::MergeTree) }
   def exported_rbi_tree; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#133
   sig { returns(T::Array[::Pathname]) }
   def files; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#130
   sig { returns(::String) }
   def full_gem_path; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#151
   sig { params(gemfile_dir: ::String).returns(T::Boolean) }
   def ignore?(gemfile_dir); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#156
   sig { returns(::String) }
   def name; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#180
   sig { void }
   def parse_yard_docs; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#166
   sig { returns(::String) }
   def rbi_file_name; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#218
   sig { params(file: ::Pathname).returns(::Pathname) }
   def relative_path_for(file); end
 
   # @return [String]
-  #
-  # source://tapioca//lib/tapioca/gemfile.rb#130
   def version; end
 
   private
 
-  # source://tapioca//lib/tapioca/gemfile.rb#229
   sig { returns(T::Array[::Pathname]) }
   def collect_files; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#244
   sig { returns(T.nilable(T::Boolean)) }
   def default_gem?; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#303
   sig { returns(T::Boolean) }
   def gem_ignored?; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#282
   sig { params(path: ::String).returns(T::Boolean) }
   def has_parent_gemspec?(path); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#249
   sig { returns(::Regexp) }
   def require_paths_prefix_matcher; end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#261
   sig { params(file: ::String).returns(::Pathname) }
   def resolve_to_ruby_lib_dir(file); end
 
-  # source://tapioca//lib/tapioca/gemfile.rb#275
   sig { returns(::String) }
   def version_string; end
 
   class << self
-    # source://tapioca//lib/tapioca/gemfile.rb#104
     sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) }
     def spec_lookup_by_file_path; end
   end
 end
 
-# source://tapioca//lib/tapioca/gemfile.rb#116
 Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca//lib/tapioca/gemfile.rb#10
 Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
-
-# source://tapioca//lib/tapioca.rb#33
 Tapioca::LIB_ROOT_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/loaders/loader.rb#5
 module Tapioca::Loaders; end
 
-# source://tapioca//lib/tapioca/loaders/dsl.rb#6
 class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
-  # source://tapioca//lib/tapioca/loaders/dsl.rb#38
   sig do
     params(
       tapioca_path: ::String,
@@ -2386,26 +1849,21 @@ class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
   end
   def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/loaders/dsl.rb#27
   sig { override.void }
   def load; end
 
   protected
 
-  # source://tapioca//lib/tapioca/loaders/dsl.rb#88
   sig { void }
   def load_application; end
 
-  # source://tapioca//lib/tapioca/loaders/dsl.rb#63
   sig { void }
   def load_dsl_compilers; end
 
-  # source://tapioca//lib/tapioca/loaders/dsl.rb#48
   sig { void }
   def load_dsl_extensions; end
 
   class << self
-    # source://tapioca//lib/tapioca/loaders/dsl.rb#15
     sig do
       params(
         tapioca_path: ::String,
@@ -2418,9 +1876,7 @@ class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
   end
 end
 
-# source://tapioca//lib/tapioca/loaders/gem.rb#6
 class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
-  # source://tapioca//lib/tapioca/loaders/gem.rb#49
   sig do
     params(
       bundle: ::Tapioca::Gemfile,
@@ -2432,22 +1888,18 @@ class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
   end
   def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
 
-  # source://tapioca//lib/tapioca/loaders/gem.rb#34
   sig { override.void }
   def load; end
 
   protected
 
-  # source://tapioca//lib/tapioca/loaders/gem.rb#80
   sig { params(file: ::String, error: ::LoadError).void }
   def explain_failed_require(file, error); end
 
-  # source://tapioca//lib/tapioca/loaders/gem.rb#60
   sig { void }
   def require_gem_file; end
 
   class << self
-    # source://tapioca//lib/tapioca/loaders/gem.rb#21
     sig do
       params(
         bundle: ::Tapioca::Gemfile,
@@ -2462,8 +1914,6 @@ class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
 end
 
 # @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca//lib/tapioca/loaders/loader.rb#6
 class Tapioca::Loaders::Loader
   include ::Thor::Base
   include ::Thor::Invocation
@@ -2476,8 +1926,6 @@ class Tapioca::Loaders::Loader
   abstract!
 
   # @abstract
-  #
-  # source://tapioca//lib/tapioca/loaders/loader.rb#17
   sig { abstract.void }
   def load; end
 
@@ -2490,20 +1938,14 @@ class Tapioca::Loaders::Loader
   #
   # @param engine [T.class_of(Rails::Engine)]
   # @return [Array<String>]
-  #
-  # source://tapioca//lib/tapioca/loaders/loader.rb#234
   def eager_load_paths(engine); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#199
   sig { void }
   def eager_load_rails_app; end
 
   # @return [Array<T.class_of(Rails::Engine)>]
-  #
-  # source://tapioca//lib/tapioca/loaders/loader.rb#178
   def engines; end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#29
   sig do
     params(
       gemfile: ::Tapioca::Gemfile,
@@ -2514,15 +1956,12 @@ class Tapioca::Loaders::Loader
   end
   def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#136
   sig { void }
   def load_engines_in_classic_mode; end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#114
   sig { void }
   def load_engines_in_zeitwerk_mode; end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#49
   sig do
     params(
       environment_load: T::Boolean,
@@ -2533,36 +1972,28 @@ class Tapioca::Loaders::Loader
   end
   def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#89
   sig { void }
   def load_rails_engines; end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#220
   sig { params(file: T.nilable(::String)).void }
   def require_helper(file); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#103
   def run_initializers; end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#192
   sig { params(path: ::String).void }
   def safe_require(path); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#161
   sig { params(blk: T.proc.void).void }
   def with_rails_application(&blk); end
 
-  # source://tapioca//lib/tapioca/loaders/loader.rb#154
   sig { returns(T::Boolean) }
   def zeitwerk_mode?; end
 end
 
-# source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#5
 module Tapioca::RBIFilesHelper
   requires_ancestor { Tapioca::SorbetHelper }
   requires_ancestor { Thor::Shell }
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#48
   sig do
     params(
       index: ::RBI::Index,
@@ -2572,19 +2003,15 @@ module Tapioca::RBIFilesHelper
   end
   def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#13
   sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void }
   def index_rbi(index, kind, file); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#25
   sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void }
   def index_rbis(index, kind, dir, number_of_workers:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#65
   sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) }
   def location_to_payload_url(loc, path_prefix:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#86
   sig do
     params(
       command: ::String,
@@ -2599,19 +2026,15 @@ module Tapioca::RBIFilesHelper
 
   private
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#223
   sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[::RBI::Scope]) }
   def extract_empty_scopes(nodes); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#228
   sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
   def extract_methods_and_attrs(nodes); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#238
   sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Mixin, ::RBI::RequiresAncestor)]) }
   def extract_mixins(nodes); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#248
   sig do
     params(
       nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
@@ -2619,7 +2042,6 @@ module Tapioca::RBIFilesHelper
   end
   def extract_nodes_with_sigs(nodes); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#216
   sig do
     params(
       nodes: T::Array[::RBI::Node],
@@ -2629,94 +2051,72 @@ module Tapioca::RBIFilesHelper
   end
   def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#280
   sig { params(path: ::String).returns(::String) }
   def gem_name_from_rbi_path(path); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#155
   sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void }
   def parse_and_index_files(index, files, number_of_workers:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#171
   sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) }
   def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#253
   sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void }
   def update_gem_rbis_strictnesses(errors, gem_dir); end
 end
 
-# source://tapioca//lib/tapioca/rbi_formatter.rb#5
 class Tapioca::RBIFormatter < ::RBI::Formatter
-  # source://tapioca//lib/tapioca/rbi_formatter.rb#24
   sig { params(file: ::RBI::File).void }
   def write_empty_body_comment!(file); end
 
-  # source://tapioca//lib/tapioca/rbi_formatter.rb#15
   sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
   def write_header!(file, command, reason: T.unsafe(nil)); end
 end
 
-# source://tapioca//lib/tapioca/helpers/rbi_helper.rb#5
 module Tapioca::RBIHelper
   include ::Tapioca::SorbetHelper
   extend ::Tapioca::SorbetHelper
   extend ::Tapioca::RBIHelper
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#91
   sig { params(type: ::String).returns(::String) }
   def as_nilable_type(type); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#100
   sig { params(type: ::String).returns(::String) }
   def as_non_nilable_type(type); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#72
   sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
   def create_block_param(name, type:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#62
   sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
   def create_kw_opt_param(name, type:, default:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#57
   sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
   def create_kw_param(name, type:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#67
   sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
   def create_kw_rest_param(name, type:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#47
   sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
   def create_opt_param(name, type:, default:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#42
   sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
   def create_param(name, type:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#52
   sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
   def create_rest_param(name, type:); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#77
   sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
   def create_typed_param(param, type); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#82
   sig { params(sig_string: ::String).returns(::String) }
   def sanitize_signature_types(sig_string); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#109
   sig { params(name: ::String).returns(T::Boolean) }
   def valid_method_name?(name); end
 
-  # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#123
   sig { params(name: ::String).returns(T::Boolean) }
   def valid_parameter_name?(name); end
 
   class << self
-    # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#23
     sig do
       params(
         type: ::String,
@@ -2730,36 +2130,28 @@ module Tapioca::RBIHelper
   end
 end
 
-# source://tapioca//lib/tapioca/repo_index.rb#5
 class Tapioca::RepoIndex
-  # source://tapioca//lib/tapioca/repo_index.rb#26
   sig { void }
   def initialize; end
 
-  # source://tapioca//lib/tapioca/repo_index.rb#31
   sig { params(gem_name: ::String).void }
   def <<(gem_name); end
 
-  # source://tapioca//lib/tapioca/repo_index.rb#36
   sig { returns(T::Enumerable[::String]) }
   def gems; end
 
-  # source://tapioca//lib/tapioca/repo_index.rb#41
   sig { params(gem_name: ::String).returns(T::Boolean) }
   def has_gem?(gem_name); end
 
   class << self
-    # source://tapioca//lib/tapioca/repo_index.rb#18
     sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(Tapioca::RepoIndex) }
     def from_hash(hash); end
 
-    # source://tapioca//lib/tapioca/repo_index.rb#13
     sig { params(json: ::String).returns(Tapioca::RepoIndex) }
     def from_json(json); end
   end
 end
 
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#5
 module Tapioca::Runtime; end
 
 # This module should only be included when running versions of Ruby
@@ -2767,74 +2159,53 @@ module Tapioca::Runtime; end
 # available, it implements finding the attached class of a singleton
 # class by iterating through ObjectSpace.
 module Tapioca::Runtime::AttachedClassOf
-  # source://tapioca//lib/tapioca/runtime/attached_class_of_32.rb#14
   sig { params(singleton_class: ::Class).returns(T.nilable(::Module)) }
   def attached_class_of(singleton_class); end
 end
 
-# source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#6
 class Tapioca::Runtime::DynamicMixinCompiler
   include ::Tapioca::Runtime::AttachedClassOf
   include ::Tapioca::Runtime::Reflection
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#20
   sig { params(constant: ::Module).void }
   def initialize(constant); end
 
   # @return [Array<Symbol>]
-  #
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
   def class_attribute_predicates; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
   sig { returns(T::Array[::Symbol]) }
   def class_attribute_readers; end
 
   # @return [Array<Symbol>]
-  #
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
   def class_attribute_writers; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#137
   sig { params(tree: ::RBI::Tree).void }
   def compile_class_attributes(tree); end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#180
   sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) }
   def compile_mixes_in_class_methods(tree); end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
   sig { returns(T::Array[::Module]) }
   def dynamic_extends; end
 
   # @return [Array<Module>]
-  #
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
   def dynamic_includes; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#132
   sig { returns(T::Boolean) }
   def empty_attributes?; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#222
   sig { params(qualified_mixin_name: ::String).returns(T::Boolean) }
   def filtered_mixin?(qualified_mixin_name); end
 
   # @return [Array<Symbol>]
-  #
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
   def instance_attribute_predicates; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
   sig { returns(T::Array[::Symbol]) }
   def instance_attribute_readers; end
 
   # @return [Array<Symbol>]
-  #
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
   def instance_attribute_writers; end
 
-  # source://tapioca//lib/tapioca/runtime/dynamic_mixin_compiler.rb#215
   sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) }
   def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
 end
@@ -2856,15 +2227,11 @@ end
 # On the other hand, if we get a result, then the result will be a hash of type
 # variable to type variable serializers. This allows us to associate type variables
 # to the constant names that represent them, easily.
-#
-# source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#23
 module Tapioca::Runtime::GenericTypeRegistry
   class << self
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#80
     sig { params(instance: ::Object).returns(T::Boolean) }
     def generic_type_instance?(instance); end
 
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#85
     sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) }
     def lookup_type_variables(constant); end
 
@@ -2879,8 +2246,6 @@ module Tapioca::Runtime::GenericTypeRegistry
     # 2 hash lookups (for the other two `Foo[Integer]`s).
     #
     # This method returns the created or cached clone of the constant.
-    #
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#65
     sig { params(constant: T.untyped, types: T.untyped).returns(::Module) }
     def register_type(constant, types); end
 
@@ -2893,34 +2258,26 @@ module Tapioca::Runtime::GenericTypeRegistry
     #
     # Finally, the original `type_variable` is returned from this method, so that the caller
     # can return it from the original methods as well.
-    #
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#104
     sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void }
     def register_type_variable(constant, type_variable); end
 
     private
 
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#113
     sig { params(constant: ::Module, name: ::String).returns(::Module) }
     def create_generic_type(constant, name); end
 
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#155
     sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) }
     def create_safe_subclass(constant); end
 
-    # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#182
     sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) }
     def lookup_or_initialize_type_variables(constant); end
   end
 end
 
-# source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#34
 class Tapioca::Runtime::GenericTypeRegistry::GenericType < ::T::Types::Simple
-  # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#38
   sig { params(raw_type: ::Module, underlying_type: ::Module).void }
   def initialize(raw_type, underlying_type); end
 
-  # source://tapioca//lib/tapioca/runtime/generic_type_registry.rb#45
   sig { override.params(obj: T.untyped).returns(T::Boolean) }
   def valid?(obj); end
 end
@@ -2930,33 +2287,25 @@ module Tapioca::Runtime::Reflection
   extend ::Tapioca::Runtime::AttachedClassOf
   extend ::Tapioca::Runtime::Reflection
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#201
   sig { params(constant: ::Module).returns(T.untyped) }
   def abstract_type_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#77
   sig { params(constant: ::Module).returns(T::Array[::Module]) }
   def ancestors_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#92
   sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) }
   def are_equal?(object, other); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#56
   sig { params(object: ::BasicObject).returns(T::Class[T.anything]) }
   def class_of(object); end
 
   # @param constant [BasicObject]
   # @return [Boolean]
-  #
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#38
   def constant_defined?(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#49
   sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) }
   def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#61
   sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
   def constants_of(constant); end
 
@@ -2973,8 +2322,6 @@ module Tapioca::Runtime::Reflection
   #
   #   class D < C; end
   #   descendants_of(C) # => [B, A, D]
-  #
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#172
   sig do
     type_parameters(:U)
       .params(
@@ -2983,152 +2330,100 @@ module Tapioca::Runtime::Reflection
   end
   def descendants_of(klass); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#194
   sig { params(constant: ::Module).returns(T::Set[::String]) }
   def file_candidates_for(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#207
   sig { params(constant: ::Module).returns(T::Boolean) }
   def final_module?(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#112
   sig { params(constant: ::Module).returns(T::Array[::Module]) }
   def inherited_ancestors_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#150
   sig { params(constant: ::Module, method: ::Symbol).returns(::Method) }
   def method_of(constant, method); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#66
   sig { params(constant: ::Module).returns(T.nilable(::String)) }
   def name_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#145
   sig { params(type: ::T::Types::Base).returns(::String) }
   def name_of_type(type); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#87
   sig { params(object: ::BasicObject).returns(::Integer) }
   def object_id_of(object); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#107
   sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
   def private_instance_methods_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#102
   sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
   def protected_instance_methods_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#97
   sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
   def public_instance_methods_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#121
   sig { params(constant: ::Module).returns(T.nilable(::String)) }
   def qualified_name_of(constant); end
 
   # Examines the call stack to identify the closest location where a "require" is performed
   # by searching for the label "<top (required)>". If none is found, it returns the location
   # labeled "<main>", which is the original call site.
-  #
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#184
   sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) }
   def resolve_loc(locations); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#212
   sig { params(constant: ::Module).returns(T::Boolean) }
   def sealed_module?(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#138
   sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
   def signature_of(method); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#133
   sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
   def signature_of!(method); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#72
   sig { params(constant: ::Module).returns(T::Class[T.anything]) }
   def singleton_class_of(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#82
   sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
   def superclass_of(constant); end
 
   private
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#249
   sig { params(parent: ::Module, name: ::String).returns(T.nilable(::Module)) }
   def child_module_for_parent_with_name(parent, name); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#265
   sig { params(name: ::String).returns(T::Boolean) }
   def has_aliased_namespace?(name); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#260
   sig { params(method: ::UnboundMethod).returns(T::Boolean) }
   def method_defined_by_forwardable_module?(method); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#235
   sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
   def methods_for(constant); end
 
-  # source://tapioca//lib/tapioca/runtime/reflection.rb#219
   sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
   def relevant_methods_for(constant); end
 end
 
-# source://tapioca//lib/tapioca/runtime/reflection.rb#25
 Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#21
 Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#22
 Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#28
 Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#32
 Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#23
 Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#27
 Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#31
 Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#30
 Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#29
 Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#35
 Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#24
 Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca//lib/tapioca/runtime/reflection.rb#26
 Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
 
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#6
 module Tapioca::Runtime::Trackers
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers.rb#34
     sig { void }
     def disable_all!; end
 
-    # source://tapioca//lib/tapioca/runtime/trackers.rb#39
     sig { params(tracker: ::Tapioca::Runtime::Trackers::Tracker).void }
     def register_tracker(tracker); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers.rb#21
     sig do
       type_parameters(:Return)
         .params(
@@ -3139,20 +2434,16 @@ module Tapioca::Runtime::Trackers
   end
 end
 
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#7
 module Tapioca::Runtime::Trackers::Autoload
   extend ::Tapioca::Runtime::Trackers::Tracker
 
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#19
     sig { void }
     def eager_load_all!; end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#31
     sig { params(constant_name: ::String).void }
     def register(constant_name); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#42
     sig do
       type_parameters(:Result)
         .params(
@@ -3163,7 +2454,6 @@ module Tapioca::Runtime::Trackers::Autoload
   end
 end
 
-# source://tapioca//lib/tapioca/runtime/trackers/autoload.rb#11
 Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc)
 
 # Registers a TracePoint immediately upon load to track points at which
@@ -3176,20 +2466,14 @@ module Tapioca::Runtime::Trackers::ConstantDefinition
   extend ::Tapioca::Runtime::Reflection
 
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#61
     def build_constant_location(tp, locations); end
-
-    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#55
     def disable!; end
 
     # Returns the files in which this class or module was opened. Doesn't know
     # about situations where the class was opened prior to +require+ing,
     # or where metaprogramming was used via +eval+, etc.
-    #
-    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#71
     def files_for(klass); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/constant_definition.rb#75
     def locations_for(klass); end
   end
 end
@@ -3198,7 +2482,6 @@ module Tapioca::Runtime::Trackers::Mixin
   extend ::Tapioca::Runtime::Trackers::Tracker
 
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#56
     sig do
       params(
         mixin: ::Module
@@ -3206,7 +2489,6 @@ module Tapioca::Runtime::Trackers::Mixin
     end
     def constants_with_mixin(mixin); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#61
     sig do
       params(
         mixin: ::Module,
@@ -3216,14 +2498,11 @@ module Tapioca::Runtime::Trackers::Mixin
     end
     def mixin_location(mixin, mixin_type, constant); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#35
     sig { params(constant: ::Module, mixin: ::Module, mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type).void }
     def register(constant, mixin, mixin_type); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#43
     def resolve_to_attached_class(constant, mixin, mixin_type); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#30
     sig do
       type_parameters(:Result)
         .params(
@@ -3234,7 +2513,6 @@ module Tapioca::Runtime::Trackers::Mixin
 
     private
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#76
     sig do
       params(
         mixin: ::Module
@@ -3242,7 +2520,6 @@ module Tapioca::Runtime::Trackers::Mixin
     end
     def find_or_initialize_mixin_lookup(mixin); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#68
     sig do
       params(
         constant: ::Module,
@@ -3257,26 +2534,22 @@ end
 
 class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
   enums do
-    Prepend = new
-    Include = new
     Extend = new
+    Include = new
+    Prepend = new
   end
 end
 
-# source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#7
 module Tapioca::Runtime::Trackers::RequiredAncestor
   extend ::Tapioca::Runtime::Trackers::Tracker
 
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#15
     sig { params(requiring: ::T::Helpers, block: T.proc.void).void }
     def register(requiring, block); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#23
     sig { params(mod: ::Module).returns(T::Array[T.proc.void]) }
     def required_ancestors_blocks_by(mod); end
 
-    # source://tapioca//lib/tapioca/runtime/trackers/required_ancestor.rb#28
     sig { params(mod: ::Module).returns(T::Array[T.untyped]) }
     def required_ancestors_by(mod); end
   end
@@ -3286,176 +2559,120 @@ end
 module Tapioca::Runtime::Trackers::Tracker
   abstract!
 
-  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#26
   sig { void }
   def disable!; end
 
   # @return [Boolean]
-  #
-  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#30
   def enabled?; end
 
-  # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#34
   def with_disabled_tracker(&block); end
 
   class << self
-    # source://tapioca//lib/tapioca/runtime/trackers/tracker.rb#17
     sig { params(base: T.all(::Module, ::Tapioca::Runtime::Trackers::Tracker)).void }
     def extended(base); end
   end
 end
 
-# source://tapioca//lib/tapioca.rb#35
 Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#34
 Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#5
 module Tapioca::SorbetHelper
-  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#32
   sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
   def sorbet(*sorbet_args); end
 
-  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#37
   sig { returns(::String) }
   def sorbet_path; end
 
-  # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#44
   sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
   def sorbet_supports?(feature, version: T.unsafe(nil)); end
 end
 
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#24
 Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
-
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#13
 Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
-
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#18
 Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#8
 Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
-
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#20
 Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#22
 Tapioca::SorbetHelper::SPOOM_CONTEXT = T.let(T.unsafe(nil), Spoom::Context)
-
-# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#5
 module Tapioca::Static; end
 
-# source://tapioca//lib/tapioca/static/requires_compiler.rb#6
 class Tapioca::Static::RequiresCompiler
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#10
   sig { params(sorbet_path: ::String).void }
   def initialize(sorbet_path); end
 
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#15
   sig { returns(::String) }
   def compile; end
 
   private
 
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#29
   sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
   def collect_files(config); end
 
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#44
   sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
   def collect_requires(file_path); end
 
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#51
   sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
   def file_ignored_by_sorbet?(config, file_path); end
 
-  # source://tapioca//lib/tapioca/static/requires_compiler.rb#80
   sig { params(path: ::Pathname).returns(T::Array[::String]) }
   def path_parts(path); end
 end
 
-# source://tapioca//lib/tapioca/static/symbol_loader.rb#6
 module Tapioca::Static::SymbolLoader
   extend ::Tapioca::SorbetHelper
   extend ::Tapioca::Runtime::AttachedClassOf
   extend ::Tapioca::Runtime::Reflection
 
   class << self
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#23
     sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
     def engine_symbols(gem); end
 
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#48
     sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
     def gem_symbols(gem); end
 
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#13
     sig { returns(T::Set[::String]) }
     def payload_symbols; end
 
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#53
     sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
     def symbols_from_paths(paths); end
 
     private
 
     # @return [Array<T.class_of(Rails::Engine)>]
-    #
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#69
     def engines; end
 
-    # source://tapioca//lib/tapioca/static/symbol_loader.rb#82
     sig { params(input: ::String, table_type: ::String).returns(::String) }
     def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
   end
 end
 
-# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#6
 class Tapioca::Static::SymbolTableParser
-  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#30
   sig { void }
   def initialize; end
 
-  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#65
   sig { params(name: ::String).returns(::String) }
   def fully_qualified_name(name); end
 
-  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#36
   sig { params(object: T::Hash[::String, T.untyped]).void }
   def parse_object(object); end
 
-  # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#27
   sig { returns(T::Set[::String]) }
   def symbols; end
 
   class << self
-    # source://tapioca//lib/tapioca/static/symbol_table_parser.rb#15
     sig { params(json_string: ::String).returns(T::Set[::String]) }
     def parse_json(json_string); end
   end
 end
 
-# source://tapioca//lib/tapioca/static/symbol_table_parser.rb#9
 Tapioca::Static::SymbolTableParser::SKIP_PARSE_KINDS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca//lib/tapioca.rb#37
 Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca//lib/tapioca.rb#36
 Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#108
 class Tapioca::TypeVariable < ::T::Types::TypeVariable
   # @return [TypeVariable] a new instance of TypeVariable
-  #
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#109
   def initialize(name, variance); end
 
   # Returns the value of attribute name.
-  #
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#114
   def name; end
 end
 
@@ -3464,10 +2681,7 @@ end
 # get bound to the constant names they are assigned to by Ruby. As a result, we don't
 # need to do any matching of constants to type variables to bind their names, Ruby will
 # do that automatically for us and we get the `name` method for free from `Module`.
-#
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#122
 class Tapioca::TypeVariableModule < ::Module
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#146
   sig do
     params(
       context: ::Module,
@@ -3478,74 +2692,57 @@ class Tapioca::TypeVariableModule < ::Module
   end
   def initialize(context, type, variance, bounds_proc); end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#181
   sig { returns(::Tapioca::TypeVariable) }
   def coerce_to_type_variable; end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#161
   sig { returns(T::Boolean) }
   def fixed?; end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#155
   sig { returns(T.nilable(::String)) }
   def name; end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#166
   sig { returns(::String) }
   def serialize; end
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#136
   sig { returns(::Tapioca::TypeVariableModule::Type) }
   def type; end
 
   private
 
-  # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#188
   sig { returns(T::Hash[::Symbol, T.untyped]) }
   def bounds; end
 end
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#133
 Tapioca::TypeVariableModule::DEFAULT_BOUNDS_PROC = T.let(T.unsafe(nil), Proc)
 
-# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#125
 class Tapioca::TypeVariableModule::Type < ::T::Enum
   enums do
+    HasAttachedClass = new
     Member = new
     Template = new
-    HasAttachedClass = new
   end
 end
 
-# source://tapioca//lib/tapioca/version.rb#5
 Tapioca::VERSION = T.let(T.unsafe(nil), String)
 
-# source://tapioca//lib/tapioca/helpers/source_uri.rb#7
 class URI::Source < ::URI::File
-  # source://tapioca//lib/tapioca/helpers/source_uri.rb#58
   sig { params(v: T.nilable(::String)).returns(T::Boolean) }
   def check_host(v); end
 
-  # source://uri/0.13.1/uri/generic.rb#243
   def gem_name; end
 
-  # source://tapioca//lib/tapioca/helpers/source_uri.rb#25
   sig { returns(T.nilable(::String)) }
   def gem_version; end
 
-  # source://uri/0.13.1/uri/generic.rb#283
   def line_number; end
 
-  # source://tapioca//lib/tapioca/helpers/source_uri.rb#51
   sig { params(v: T.nilable(::String)).void }
   def set_path(v); end
 
-  # source://tapioca//lib/tapioca/helpers/source_uri.rb#70
   sig { returns(::String) }
   def to_s; end
 
   class << self
-    # source://tapioca//lib/tapioca/helpers/source_uri.rb#38
     sig do
       params(
         gem_name: ::String,
@@ -3558,5 +2755,4 @@ class URI::Source < ::URI::File
   end
 end
 
-# source://tapioca//lib/tapioca/helpers/source_uri.rb#10
 URI::Source::COMPONENT = T.let(T.unsafe(nil), Array)
diff --git a/sorbet/tapioca/require.rb b/sorbet/tapioca/require.rb
index 4243632..b867b46 100644
--- a/sorbet/tapioca/require.rb
+++ b/sorbet/tapioca/require.rb
@@ -6,4 +6,5 @@
 require "rails/all"
 require "rails/generators"
 require "rails/generators/app_base"
+require "tapioca/dsl/compilers"
 require "zeitwerk"