diff --git a/2023/.ruby-version b/2023/.ruby-version
new file mode 100644
index 0000000..be94e6f
--- /dev/null
+++ b/2023/.ruby-version
@@ -0,0 +1 @@
+3.2.2
diff --git a/2023/Gemfile b/2023/Gemfile
new file mode 100644
index 0000000..72759b8
--- /dev/null
+++ b/2023/Gemfile
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem 'sorbet-static-and-runtime'
+gem 'sorbet-struct-comparable'
+gem 'tapioca', require: false, :group => :development
diff --git a/2023/Gemfile.lock b/2023/Gemfile.lock
new file mode 100644
index 0000000..31f9235
--- /dev/null
+++ b/2023/Gemfile.lock
@@ -0,0 +1,52 @@
+GEM
+ remote: https://rubygems.org/
+ specs:
+ erubi (1.12.0)
+ netrc (0.11.0)
+ parallel (1.24.0)
+ prettier_print (1.2.1)
+ prism (0.19.0)
+ rbi (0.1.6)
+ prism (>= 0.18.0, < 0.20)
+ sorbet-runtime (>= 0.5.9204)
+ sorbet (0.5.11162)
+ sorbet-static (= 0.5.11162)
+ sorbet-runtime (0.5.11162)
+ sorbet-static (0.5.11162-x86_64-linux)
+ sorbet-static-and-runtime (0.5.11162)
+ sorbet (= 0.5.11162)
+ sorbet-runtime (= 0.5.11162)
+ sorbet-struct-comparable (1.3.0)
+ sorbet-runtime (>= 0.5)
+ spoom (1.2.4)
+ erubi (>= 1.10.0)
+ sorbet-static-and-runtime (>= 0.5.10187)
+ syntax_tree (>= 6.1.1)
+ thor (>= 0.19.2)
+ syntax_tree (6.2.0)
+ prettier_print (>= 1.2.0)
+ tapioca (0.11.14)
+ bundler (>= 2.2.25)
+ netrc (>= 0.11.0)
+ parallel (>= 1.21.0)
+ rbi (>= 0.1.4, < 0.2)
+ sorbet-static-and-runtime (>= 0.5.10187)
+ spoom (~> 1.2.0, >= 1.2.0)
+ thor (>= 1.2.0)
+ yard-sorbet
+ thor (1.3.0)
+ yard (0.9.34)
+ yard-sorbet (0.8.1)
+ sorbet-runtime (>= 0.5)
+ yard (>= 0.9)
+
+PLATFORMS
+ x86_64-linux
+
+DEPENDENCIES
+ sorbet-static-and-runtime
+ sorbet-struct-comparable
+ tapioca
+
+BUNDLED WITH
+ 2.4.10
diff --git a/2023/bin/tapioca b/2023/bin/tapioca
new file mode 100755
index 0000000..a6ae757
--- /dev/null
+++ b/2023/bin/tapioca
@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+ if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+ load(bundle_binstub)
+ else
+ abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+ end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")
diff --git a/2023/sorbet/config b/2023/sorbet/config
new file mode 100644
index 0000000..983d2f1
--- /dev/null
+++ b/2023/sorbet/config
@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/
diff --git a/2023/sorbet/rbi/gems/.gitattributes b/2023/sorbet/rbi/gems/.gitattributes
new file mode 100644
index 0000000..d9bb82a
--- /dev/null
+++ b/2023/sorbet/rbi/gems/.gitattributes
@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true
diff --git a/2023/sorbet/rbi/gems/erubi@1.12.0.rbi b/2023/sorbet/rbi/gems/erubi@1.12.0.rbi
new file mode 100644
index 0000000..c52738f
--- /dev/null
+++ b/2023/sorbet/rbi/gems/erubi@1.12.0.rbi
@@ -0,0 +1,145 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `erubi` gem.
+# Please instead update this file by running `bin/tapioca gem erubi`.
+
+# source://erubi//lib/erubi.rb#3
+module Erubi
+ class << self
+ def h(_arg0); end
+ end
+end
+
+# source://erubi//lib/erubi.rb#54
+class Erubi::Engine
+ # Initialize a new Erubi::Engine. Options:
+ # +:bufval+ :: The value to use for the buffer variable, as a string (default '::String.new').
+ # +:bufvar+ :: The variable name to use for the buffer variable, as a string.
+ # +:chain_appends+ :: Whether to chain << calls to the buffer variable. Offers better
+ # performance, but can cause issues when the buffer variable is reassigned during
+ # template rendering (default +false+).
+ # +:ensure+ :: Wrap the template in a begin/ensure block restoring the previous value of bufvar.
+ # +:escapefunc+ :: The function to use for escaping, as a string (default: '::Erubi.h').
+ # +:escape+ :: Whether to make <%= escape by default, and <%== not escape by default.
+ # +:escape_html+ :: Same as +:escape+, with lower priority.
+ # +:filename+ :: The filename for the template.
+ # the resulting source code. Note this may cause problems if you are wrapping the resulting
+ # source code in other code, because the magic comment only has an effect at the beginning of
+ # the file, and having the magic comment later in the file can trigger warnings.
+ # +:freeze_template_literals+ :: Whether to suffix all literal strings for template code with .freeze
+ # (default: +true+ on Ruby 2.1+, +false+ on Ruby 2.0 and older).
+ # Can be set to +false+ on Ruby 2.3+ when frozen string literals are enabled
+ # in order to improve performance.
+ # +:literal_prefix+ :: The prefix to output when using escaped tag delimiters (default '<%').
+ # +:literal_postfix+ :: The postfix to output when using escaped tag delimiters (default '%>').
+ # +:outvar+ :: Same as +:bufvar+, with lower priority.
+ # +:postamble+ :: The postamble for the template, by default returns the resulting source code.
+ # +:preamble+ :: The preamble for the template, by default initializes the buffer variable.
+ # +:regexp+ :: The regexp to use for scanning.
+ # +:src+ :: The initial value to use for the source code, an empty string by default.
+ # +:trim+ :: Whether to trim leading and trailing whitespace, true by default.
+ #
+ # @return [Engine] a new instance of Engine
+ #
+ # source://erubi//lib/erubi.rb#94
+ def initialize(input, properties = T.unsafe(nil)); end
+
+ # The variable name used for the buffer variable.
+ #
+ # source://erubi//lib/erubi.rb#65
+ def bufvar; end
+
+ # The filename of the template, if one was given.
+ #
+ # source://erubi//lib/erubi.rb#62
+ def filename; end
+
+ # The frozen ruby source code generated from the template, which can be evaled.
+ #
+ # source://erubi//lib/erubi.rb#59
+ def src; end
+
+ private
+
+ # Add ruby code to the template
+ #
+ # source://erubi//lib/erubi.rb#226
+ def add_code(code); end
+
+ # Add the given ruby expression result to the template,
+ # escaping it based on the indicator given and escape flag.
+ #
+ # source://erubi//lib/erubi.rb#235
+ def add_expression(indicator, code); end
+
+ # Add the result of Ruby expression to the template
+ #
+ # source://erubi//lib/erubi.rb#244
+ def add_expression_result(code); end
+
+ # Add the escaped result of Ruby expression to the template
+ #
+ # source://erubi//lib/erubi.rb#249
+ def add_expression_result_escaped(code); end
+
+ # Add the given postamble to the src. Can be overridden in subclasses
+ # to make additional changes to src that depend on the current state.
+ #
+ # source://erubi//lib/erubi.rb#255
+ def add_postamble(postamble); end
+
+ # Add raw text to the template. Modifies argument if argument is mutable as a memory optimization.
+ # Must be called with a string, cannot be called with nil (Rails's subclass depends on it).
+ #
+ # source://erubi//lib/erubi.rb#213
+ def add_text(text); end
+
+ # Raise an exception, as the base engine class does not support handling other indicators.
+ #
+ # @raise [ArgumentError]
+ #
+ # source://erubi//lib/erubi.rb#261
+ def handle(indicator, code, tailch, rspace, lspace); end
+
+ # Make sure that any current expression has been terminated.
+ # The default is to terminate all expressions, but when
+ # the chain_appends option is used, expressions may not be
+ # terminated.
+ #
+ # source://erubi//lib/erubi.rb#289
+ def terminate_expression; end
+
+ # Make sure the buffer variable is the target of the next append
+ # before yielding to the block. Mark that the buffer is the target
+ # of the next append after the block executes.
+ #
+ # This method should only be called if the block will result in
+ # code where << will append to the bufvar.
+ #
+ # source://erubi//lib/erubi.rb#271
+ def with_buffer; end
+end
+
+# The default regular expression used for scanning.
+#
+# source://erubi//lib/erubi.rb#56
+Erubi::Engine::DEFAULT_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://erubi//lib/erubi.rb#17
+Erubi::FREEZE_TEMPLATE_LITERALS = T.let(T.unsafe(nil), TrueClass)
+
+# source://erubi//lib/erubi.rb#15
+Erubi::MATCH_METHOD = T.let(T.unsafe(nil), Symbol)
+
+# source://erubi//lib/erubi.rb#8
+Erubi::RANGE_FIRST = T.let(T.unsafe(nil), Integer)
+
+# source://erubi//lib/erubi.rb#9
+Erubi::RANGE_LAST = T.let(T.unsafe(nil), Integer)
+
+# source://erubi//lib/erubi.rb#16
+Erubi::SKIP_DEFINED_FOR_INSTANCE_VARIABLE = T.let(T.unsafe(nil), TrueClass)
+
+# source://erubi//lib/erubi.rb#4
+Erubi::VERSION = T.let(T.unsafe(nil), String)
diff --git a/2023/sorbet/rbi/gems/netrc@0.11.0.rbi b/2023/sorbet/rbi/gems/netrc@0.11.0.rbi
new file mode 100644
index 0000000..062a557
--- /dev/null
+++ b/2023/sorbet/rbi/gems/netrc@0.11.0.rbi
@@ -0,0 +1,158 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `netrc` gem.
+# Please instead update this file by running `bin/tapioca gem netrc`.
+
+# source://netrc//lib/netrc.rb#3
+class Netrc
+ # @return [Netrc] a new instance of Netrc
+ #
+ # source://netrc//lib/netrc.rb#166
+ def initialize(path, data); end
+
+ # source://netrc//lib/netrc.rb#180
+ def [](k); end
+
+ # source://netrc//lib/netrc.rb#188
+ def []=(k, info); end
+
+ # source://netrc//lib/netrc.rb#200
+ def delete(key); end
+
+ # source://netrc//lib/netrc.rb#211
+ def each(&block); end
+
+ # source://netrc//lib/netrc.rb#196
+ def length; end
+
+ # source://netrc//lib/netrc.rb#215
+ def new_item(m, l, p); end
+
+ # Returns the value of attribute new_item_prefix.
+ #
+ # source://netrc//lib/netrc.rb#178
+ def new_item_prefix; end
+
+ # Sets the attribute new_item_prefix
+ #
+ # @param value the value to set the attribute new_item_prefix to.
+ #
+ # source://netrc//lib/netrc.rb#178
+ def new_item_prefix=(_arg0); end
+
+ # source://netrc//lib/netrc.rb#219
+ def save; end
+
+ # source://netrc//lib/netrc.rb#233
+ def unparse; end
+
+ class << self
+ # source://netrc//lib/netrc.rb#42
+ def check_permissions(path); end
+
+ # source://netrc//lib/netrc.rb#33
+ def config; end
+
+ # @yield [self.config]
+ #
+ # source://netrc//lib/netrc.rb#37
+ def configure; end
+
+ # source://netrc//lib/netrc.rb#10
+ def default_path; end
+
+ # source://netrc//lib/netrc.rb#14
+ def home_path; end
+
+ # source://netrc//lib/netrc.rb#85
+ def lex(lines); end
+
+ # source://netrc//lib/netrc.rb#29
+ def netrc_filename; end
+
+ # Returns two values, a header and a list of items.
+ # Each item is a tuple, containing some or all of:
+ # - machine keyword (including trailing whitespace+comments)
+ # - machine name
+ # - login keyword (including surrounding whitespace+comments)
+ # - login
+ # - password keyword (including surrounding whitespace+comments)
+ # - password
+ # - trailing chars
+ # This lets us change individual fields, then write out the file
+ # with all its original formatting.
+ #
+ # source://netrc//lib/netrc.rb#129
+ def parse(ts); end
+
+ # Reads path and parses it as a .netrc file. If path doesn't
+ # exist, returns an empty object. Decrypt paths ending in .gpg.
+ #
+ # source://netrc//lib/netrc.rb#51
+ def read(path = T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://netrc//lib/netrc.rb#112
+ def skip?(s); end
+ end
+end
+
+# source://netrc//lib/netrc.rb#8
+Netrc::CYGWIN = T.let(T.unsafe(nil), T.untyped)
+
+# source://netrc//lib/netrc.rb#244
+class Netrc::Entry < ::Struct
+ # Returns the value of attribute login
+ #
+ # @return [Object] the current value of login
+ def login; end
+
+ # Sets the attribute login
+ #
+ # @param value [Object] the value to set the attribute login to.
+ # @return [Object] the newly set value
+ def login=(_); end
+
+ # Returns the value of attribute password
+ #
+ # @return [Object] the current value of password
+ def password; end
+
+ # Sets the attribute password
+ #
+ # @param value [Object] the value to set the attribute password to.
+ # @return [Object] the newly set value
+ def password=(_); end
+
+ def to_ary; end
+
+ class << self
+ def [](*_arg0); end
+ def inspect; end
+ def keyword_init?; end
+ def members; end
+ def new(*_arg0); end
+ end
+end
+
+# source://netrc//lib/netrc.rb#250
+class Netrc::Error < ::StandardError; end
+
+# source://netrc//lib/netrc.rb#68
+class Netrc::TokenArray < ::Array
+ # source://netrc//lib/netrc.rb#76
+ def readto; end
+
+ # source://netrc//lib/netrc.rb#69
+ def take; end
+end
+
+# source://netrc//lib/netrc.rb#4
+Netrc::VERSION = T.let(T.unsafe(nil), String)
+
+# see http://stackoverflow.com/questions/4871309/what-is-the-correct-way-to-detect-if-ruby-is-running-on-windows
+#
+# source://netrc//lib/netrc.rb#7
+Netrc::WINDOWS = T.let(T.unsafe(nil), T.untyped)
diff --git a/2023/sorbet/rbi/gems/parallel@1.24.0.rbi b/2023/sorbet/rbi/gems/parallel@1.24.0.rbi
new file mode 100644
index 0000000..5dd7375
--- /dev/null
+++ b/2023/sorbet/rbi/gems/parallel@1.24.0.rbi
@@ -0,0 +1,280 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parallel` gem.
+# Please instead update this file by running `bin/tapioca gem parallel`.
+
+# source://parallel//lib/parallel/version.rb#2
+module Parallel
+ class << self
+ # @return [Boolean]
+ #
+ # source://parallel//lib/parallel.rb#243
+ def all?(*args, &block); end
+
+ # @return [Boolean]
+ #
+ # source://parallel//lib/parallel.rb#238
+ def any?(*args, &block); end
+
+ # source://parallel//lib/parallel.rb#234
+ def each(array, options = T.unsafe(nil), &block); end
+
+ # source://parallel//lib/parallel.rb#248
+ def each_with_index(array, options = T.unsafe(nil), &block); end
+
+ # source://parallel//lib/parallel.rb#307
+ def filter_map(*args, &block); end
+
+ # source://parallel//lib/parallel.rb#303
+ def flat_map(*args, &block); end
+
+ # source://parallel//lib/parallel.rb#228
+ def in_processes(options = T.unsafe(nil), &block); end
+
+ # source://parallel//lib/parallel.rb#212
+ def in_threads(options = T.unsafe(nil)); end
+
+ # source://parallel//lib/parallel.rb#252
+ def map(source, options = T.unsafe(nil), &block); end
+
+ # source://parallel//lib/parallel.rb#299
+ def map_with_index(array, options = T.unsafe(nil), &block); end
+
+ # Number of physical processor cores on the current system.
+ #
+ # source://parallel//lib/parallel.rb#312
+ def physical_processor_count; end
+
+ # Number of processors seen by the OS, used for process scheduling
+ #
+ # source://parallel//lib/parallel.rb#345
+ def processor_count; end
+
+ # source://parallel//lib/parallel.rb#350
+ def worker_number; end
+
+ # TODO: this does not work when doing threads in forks, so should remove and yield the number instead if needed
+ #
+ # source://parallel//lib/parallel.rb#355
+ def worker_number=(worker_num); end
+
+ private
+
+ # source://parallel//lib/parallel.rb#361
+ def add_progress_bar!(job_factory, options); end
+
+ # source://parallel//lib/parallel.rb#624
+ def call_with_index(item, index, options, &block); end
+
+ # source://parallel//lib/parallel.rb#556
+ def create_workers(job_factory, options, &block); end
+
+ # options is either a Integer or a Hash with :count
+ #
+ # source://parallel//lib/parallel.rb#614
+ def extract_count_from_options(options); end
+
+ # source://parallel//lib/parallel.rb#642
+ def instrument_finish(item, index, result, options); end
+
+ # yield results in the order of the input items
+ # needs to use `options` to store state between executions
+ # needs to use `done` index since a nil result would also be valid
+ #
+ # source://parallel//lib/parallel.rb#651
+ def instrument_finish_in_order(item, index, result, options); end
+
+ # source://parallel//lib/parallel.rb#671
+ def instrument_start(item, index, options); end
+
+ # source://parallel//lib/parallel.rb#590
+ def process_incoming_jobs(read, write, job_factory, options, &block); end
+
+ # source://parallel//lib/parallel.rb#544
+ def replace_worker(job_factory, workers, index, options, blk); end
+
+ # source://parallel//lib/parallel.rb#635
+ def with_instrumentation(item, index, options); end
+
+ # source://parallel//lib/parallel.rb#386
+ def work_direct(job_factory, options, &block); end
+
+ # source://parallel//lib/parallel.rb#496
+ def work_in_processes(job_factory, options, &blk); end
+
+ # source://parallel//lib/parallel.rb#430
+ def work_in_ractors(job_factory, options); end
+
+ # source://parallel//lib/parallel.rb#405
+ def work_in_threads(job_factory, options, &block); end
+
+ # source://parallel//lib/parallel.rb#564
+ def worker(job_factory, options, &block); end
+ end
+end
+
+# source://parallel//lib/parallel.rb#11
+class Parallel::Break < ::StandardError
+ # @return [Break] a new instance of Break
+ #
+ # source://parallel//lib/parallel.rb#14
+ def initialize(value = T.unsafe(nil)); end
+
+ # Returns the value of attribute value.
+ #
+ # source://parallel//lib/parallel.rb#12
+ def value; end
+end
+
+# source://parallel//lib/parallel.rb#8
+class Parallel::DeadWorker < ::StandardError; end
+
+# source://parallel//lib/parallel.rb#32
+class Parallel::ExceptionWrapper
+ # @return [ExceptionWrapper] a new instance of ExceptionWrapper
+ #
+ # source://parallel//lib/parallel.rb#35
+ def initialize(exception); end
+
+ # Returns the value of attribute exception.
+ #
+ # source://parallel//lib/parallel.rb#33
+ def exception; end
+end
+
+# source://parallel//lib/parallel.rb#98
+class Parallel::JobFactory
+ # @return [JobFactory] a new instance of JobFactory
+ #
+ # source://parallel//lib/parallel.rb#99
+ def initialize(source, mutex); end
+
+ # source://parallel//lib/parallel.rb#107
+ def next; end
+
+ # generate item that is sent to workers
+ # just index is faster + less likely to blow up with unserializable errors
+ #
+ # source://parallel//lib/parallel.rb#136
+ def pack(item, index); end
+
+ # source://parallel//lib/parallel.rb#126
+ def size; end
+
+ # unpack item that is sent to workers
+ #
+ # source://parallel//lib/parallel.rb#141
+ def unpack(data); end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://parallel//lib/parallel.rb#147
+ def producer?; end
+
+ # source://parallel//lib/parallel.rb#151
+ def queue_wrapper(array); end
+end
+
+# source://parallel//lib/parallel.rb#20
+class Parallel::Kill < ::Parallel::Break; end
+
+# source://parallel//lib/parallel.rb#6
+Parallel::Stop = T.let(T.unsafe(nil), Object)
+
+# source://parallel//lib/parallel.rb#23
+class Parallel::UndumpableException < ::StandardError
+ # @return [UndumpableException] a new instance of UndumpableException
+ #
+ # source://parallel//lib/parallel.rb#26
+ def initialize(original); end
+
+ # Returns the value of attribute backtrace.
+ #
+ # source://parallel//lib/parallel.rb#24
+ def backtrace; end
+end
+
+# source://parallel//lib/parallel.rb#156
+class Parallel::UserInterruptHandler
+ class << self
+ # source://parallel//lib/parallel.rb#181
+ def kill(thing); end
+
+ # kill all these pids or threads if user presses Ctrl+c
+ #
+ # source://parallel//lib/parallel.rb#161
+ def kill_on_ctrl_c(pids, options); end
+
+ private
+
+ # source://parallel//lib/parallel.rb#205
+ def restore_interrupt(old, signal); end
+
+ # source://parallel//lib/parallel.rb#190
+ def trap_interrupt(signal); end
+ end
+end
+
+# source://parallel//lib/parallel.rb#157
+Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
+
+# source://parallel//lib/parallel/version.rb#3
+Parallel::VERSION = T.let(T.unsafe(nil), String)
+
+# source://parallel//lib/parallel/version.rb#3
+Parallel::Version = T.let(T.unsafe(nil), String)
+
+# source://parallel//lib/parallel.rb#51
+class Parallel::Worker
+ # @return [Worker] a new instance of Worker
+ #
+ # source://parallel//lib/parallel.rb#55
+ def initialize(read, write, pid); end
+
+ # might be passed to started_processes and simultaneously closed by another thread
+ # when running in isolation mode, so we have to check if it is closed before closing
+ #
+ # source://parallel//lib/parallel.rb#68
+ def close_pipes; end
+
+ # Returns the value of attribute pid.
+ #
+ # source://parallel//lib/parallel.rb#52
+ def pid; end
+
+ # Returns the value of attribute read.
+ #
+ # source://parallel//lib/parallel.rb#52
+ def read; end
+
+ # source://parallel//lib/parallel.rb#61
+ def stop; end
+
+ # Returns the value of attribute thread.
+ #
+ # source://parallel//lib/parallel.rb#53
+ def thread; end
+
+ # Sets the attribute thread
+ #
+ # @param value the value to set the attribute thread to.
+ #
+ # source://parallel//lib/parallel.rb#53
+ def thread=(_arg0); end
+
+ # source://parallel//lib/parallel.rb#73
+ def work(data); end
+
+ # Returns the value of attribute write.
+ #
+ # source://parallel//lib/parallel.rb#52
+ def write; end
+
+ private
+
+ # source://parallel//lib/parallel.rb#91
+ def wait; end
+end
diff --git a/2023/sorbet/rbi/gems/prettier_print@1.2.1.rbi b/2023/sorbet/rbi/gems/prettier_print@1.2.1.rbi
new file mode 100644
index 0000000..4e88525
--- /dev/null
+++ b/2023/sorbet/rbi/gems/prettier_print@1.2.1.rbi
@@ -0,0 +1,951 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `prettier_print` gem.
+# Please instead update this file by running `bin/tapioca gem prettier_print`.
+
+# This class implements a pretty printing algorithm. It finds line breaks and
+# nice indentations for grouped structure.
+#
+# By default, the class assumes that primitive elements are strings and each
+# byte in the strings is a single column in width. But it can be used for other
+# situations by giving suitable arguments for some methods:
+#
+# * newline object and space generation block for PrettierPrint.new
+# * optional width argument for PrettierPrint#text
+# * PrettierPrint#breakable
+#
+# There are several candidate uses:
+# * text formatting using proportional fonts
+# * multibyte characters which has columns different to number of bytes
+# * non-string formatting
+#
+# == Usage
+#
+# To use this module, you will need to generate a tree of print nodes that
+# represent indentation and newline behavior before it gets sent to the printer.
+# Each node has different semantics, depending on the desired output.
+#
+# The most basic node is a Text node. This represents plain text content that
+# cannot be broken up even if it doesn't fit on one line. You would create one
+# of those with the text method, as in:
+#
+# PrettierPrint.format { |q| q.text('my content') }
+#
+# No matter what the desired output width is, the output for the snippet above
+# will always be the same.
+#
+# If you want to allow the printer to break up the content on the space
+# character when there isn't enough width for the full string on the same line,
+# you can use the Breakable and Group nodes. For example:
+#
+# PrettierPrint.format do |q|
+# q.group do
+# q.text("my")
+# q.breakable
+# q.text("content")
+# end
+# end
+#
+# Now, if everything fits on one line (depending on the maximum width specified)
+# then it will be the same output as the first example. If, however, there is
+# not enough room on the line, then you will get two lines of output, one for
+# the first string and one for the second.
+#
+# There are other nodes for the print tree as well, described in the
+# documentation below. They control alignment, indentation, conditional
+# formatting, and more.
+#
+# == References
+# Christian Lindig, Strictly Pretty, March 2000
+# https://lindig.github.io/papers/strictly-pretty-2000.pdf
+#
+# Philip Wadler, A prettier printer, March 1998
+# https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
+#
+# source://prettier_print//lib/prettier_print.rb#62
+class PrettierPrint
+ # Creates a buffer for pretty printing.
+ #
+ # +output+ is an output target. If it is not specified, '' is assumed. It
+ # should have a << method which accepts the first argument +obj+ of
+ # PrettierPrint#text, the first argument +separator+ of PrettierPrint#breakable,
+ # the first argument +newline+ of PrettierPrint.new, and the result of a given
+ # block for PrettierPrint.new.
+ #
+ # +maxwidth+ specifies maximum line length. If it is not specified, 80 is
+ # assumed. However actual outputs may overflow +maxwidth+ if long
+ # non-breakable texts are provided.
+ #
+ # +newline+ is used for line breaks. "\n" is used if it is not specified.
+ #
+ # The block is used to generate spaces. ->(n) { ' ' * n } is used if it is not
+ # given.
+ #
+ # @return [PrettierPrint] a new instance of PrettierPrint
+ #
+ # source://prettier_print//lib/prettier_print.rb#441
+ def initialize(output = T.unsafe(nil), maxwidth = T.unsafe(nil), newline = T.unsafe(nil), &genspace); end
+
+ # This inserts a BreakParent node into the print tree which forces the
+ # surrounding and all parent group nodes to break.
+ #
+ # source://prettier_print//lib/prettier_print.rb#814
+ def break_parent; end
+
+ # This says "you can break a line here if necessary", and a +width+\-column
+ # text +separator+ is inserted if a line is not broken at the point.
+ #
+ # If +separator+ is not specified, ' ' is used.
+ #
+ # If +width+ is not specified, +separator.length+ is used. You will have to
+ # specify this when +separator+ is a multibyte character, for example.
+ #
+ # By default, if the surrounding group is broken and a newline is inserted,
+ # the printer will indent the subsequent line up to the current level of
+ # indentation. You can disable this behavior with the +indent+ argument if
+ # that's not desired (rare).
+ #
+ # By default, when you insert a Breakable into the print tree, it only breaks
+ # the surrounding group when the group's contents cannot fit onto the
+ # remaining space of the current line. You can force it to break the
+ # surrounding group instead if you always want the newline with the +force+
+ # argument.
+ #
+ # There are a few circumstances where you'll want to force the newline into
+ # the output but no insert a break parent (because you don't want to
+ # necessarily force the groups to break unless they need to). In this case you
+ # can pass `force: :skip_break_parent` to this method and it will not insert
+ # a break parent.`
+ #
+ # source://prettier_print//lib/prettier_print.rb#802
+ def breakable(separator = T.unsafe(nil), width = T.unsafe(nil), indent: T.unsafe(nil), force: T.unsafe(nil)); end
+
+ # Another very common breakable call you receive while formatting is an
+ # empty string in flat mode and a newline in break mode. Similar to
+ # breakable_space, this is here for avoid unnecessary calculation.
+ #
+ # source://prettier_print//lib/prettier_print.rb#646
+ def breakable_empty; end
+
+ # The final of the very common breakable calls you receive while formatting
+ # is the normal breakable space but with the addition of the break_parent.
+ #
+ # source://prettier_print//lib/prettier_print.rb#652
+ def breakable_force; end
+
+ # This is the same shortcut as breakable_force, except that it doesn't indent
+ # the next line. This is necessary if you're trying to preserve some custom
+ # formatting like a multi-line string.
+ #
+ # source://prettier_print//lib/prettier_print.rb#660
+ def breakable_return; end
+
+ # The vast majority of breakable calls you receive while formatting are a
+ # space in flat mode and a newline in break mode. Since this is so common,
+ # we have a method here to skip past unnecessary calculation.
+ #
+ # source://prettier_print//lib/prettier_print.rb#639
+ def breakable_space; end
+
+ # This is an output buffer that wraps the output object and provides
+ # additional functionality depending on its type.
+ #
+ # This defaults to Buffer::StringBuffer.new("".dup)
+ #
+ # source://prettier_print//lib/prettier_print.rb#400
+ def buffer; end
+
+ # A convenience method which is same as follows:
+ #
+ # text(",")
+ # breakable
+ #
+ # source://prettier_print//lib/prettier_print.rb#669
+ def comma_breakable; end
+
+ # Returns the group most recently added to the stack.
+ #
+ # Contrived example:
+ # out = ""
+ # => ""
+ # q = PrettierPrint.new(out)
+ # => #
+ # q.group {
+ # q.text q.current_group.inspect
+ # q.text q.newline
+ # q.group(q.current_group.depth + 1) {
+ # q.text q.current_group.inspect
+ # q.text q.newline
+ # q.group(q.current_group.depth + 1) {
+ # q.text q.current_group.inspect
+ # q.text q.newline
+ # q.group(q.current_group.depth + 1) {
+ # q.text q.current_group.inspect
+ # q.text q.newline
+ # }
+ # }
+ # }
+ # }
+ # => 284
+ # puts out
+ # #
+ # #
+ # #
+ # #
+ #
+ # source://prettier_print//lib/prettier_print.rb#484
+ def current_group; end
+
+ # This is similar to #breakable except the decision to break or not is
+ # determined individually.
+ #
+ # Two #fill_breakable under a group may cause 4 results:
+ # (break,break), (break,non-break), (non-break,break), (non-break,non-break).
+ # This is different to #breakable because two #breakable under a group
+ # may cause 2 results: (break,break), (non-break,non-break).
+ #
+ # The text +separator+ is inserted if a line is not broken at this point.
+ #
+ # If +separator+ is not specified, ' ' is used.
+ #
+ # If +width+ is not specified, +separator.length+ is used. You will have to
+ # specify this when +separator+ is a multibyte character, for example.
+ #
+ # source://prettier_print//lib/prettier_print.rb#688
+ def fill_breakable(separator = T.unsafe(nil), width = T.unsafe(nil)); end
+
+ # Flushes all of the generated print tree onto the output buffer, then clears
+ # the generated tree from memory.
+ #
+ # source://prettier_print//lib/prettier_print.rb#490
+ def flush(base_indentation = T.unsafe(nil)); end
+
+ # An object that responds to call that takes one argument, of an Integer, and
+ # returns the corresponding number of spaces.
+ #
+ # By default this is: ->(n) { ' ' * n }
+ #
+ # source://prettier_print//lib/prettier_print.rb#416
+ def genspace; end
+
+ # Groups line break hints added in the block. The line break hints are all to
+ # be used or not.
+ #
+ # If +indent+ is specified, the method call is regarded as nested by
+ # nest(indent) { ... }.
+ #
+ # If +open_object+ is specified, text(open_object, open_width) is
+ # called before grouping. If +close_object+ is specified,
+ # text(close_object, close_width) is called after grouping.
+ #
+ # source://prettier_print//lib/prettier_print.rb#845
+ def group(indent = T.unsafe(nil), open_object = T.unsafe(nil), close_object = T.unsafe(nil), open_width = T.unsafe(nil), close_width = T.unsafe(nil)); end
+
+ # The stack of groups that are being printed.
+ #
+ # source://prettier_print//lib/prettier_print.rb#419
+ def groups; end
+
+ # Inserts an IfBreak node with the contents of the block being added to its
+ # list of nodes that should be printed if the surrounding node breaks. If it
+ # doesn't, then you can specify the contents to be printed with the #if_flat
+ # method used on the return object from this method. For example,
+ #
+ # q.if_break { q.text('do') }.if_flat { q.text('{') }
+ #
+ # In the example above, if the surrounding group is broken it will print 'do'
+ # and if it is not it will print '{'.
+ #
+ # source://prettier_print//lib/prettier_print.rb#917
+ def if_break; end
+
+ # This is similar to if_break in that it also inserts an IfBreak node into the
+ # print tree, however it's starting from the flat contents, and cannot be used
+ # to build the break contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#936
+ def if_flat; end
+
+ # Very similar to the #nest method, this indents the nested content by one
+ # level by inserting an Indent node into the print tree. The contents of the
+ # node are determined by the block.
+ #
+ # source://prettier_print//lib/prettier_print.rb#956
+ def indent; end
+
+ # This method calculates the position of the text relative to the current
+ # indentation level when the doc has been printed. It's useful for
+ # determining how to align text to doc nodes that are already built into the
+ # tree.
+ #
+ # source://prettier_print//lib/prettier_print.rb#696
+ def last_position(node); end
+
+ # Inserts a LineSuffix node into the print tree. The contents of the node are
+ # determined by the block.
+ #
+ # source://prettier_print//lib/prettier_print.rb#967
+ def line_suffix(priority: T.unsafe(nil)); end
+
+ # The maximum width of a line, before it is separated in to a newline
+ #
+ # This defaults to 80, and should be an Integer
+ #
+ # source://prettier_print//lib/prettier_print.rb#405
+ def maxwidth; end
+
+ # Increases left margin after newline with +indent+ for line breaks added in
+ # the block.
+ #
+ # source://prettier_print//lib/prettier_print.rb#977
+ def nest(indent); end
+
+ # The value that is appended to +output+ to add a new line.
+ #
+ # This defaults to "\n", and should be String
+ #
+ # source://prettier_print//lib/prettier_print.rb#410
+ def newline; end
+
+ # The output object. It represents the final destination of the contents of
+ # the print tree. It should respond to <<.
+ #
+ # This defaults to "".dup
+ #
+ # source://prettier_print//lib/prettier_print.rb#394
+ def output; end
+
+ # This method will remove any breakables from the list of contents so that
+ # no newlines are present in the output. If a newline is being forced into
+ # the output, the replace value will be used.
+ #
+ # source://prettier_print//lib/prettier_print.rb#721
+ def remove_breaks(node, replace = T.unsafe(nil)); end
+
+ # Adds a separated list.
+ # The list is separated by comma with breakable space, by default.
+ #
+ # #seplist iterates the +list+ using +iter_method+.
+ # It yields each object to the block given for #seplist.
+ # The procedure +separator_proc+ is called between each yields.
+ #
+ # If the iteration is zero times, +separator_proc+ is not called at all.
+ #
+ # If +separator_proc+ is nil or not given,
+ # +lambda { comma_breakable }+ is used.
+ # If +iter_method+ is not given, :each is used.
+ #
+ # For example, following 3 code fragments has similar effect.
+ #
+ # q.seplist([1,2,3]) {|v| xxx v }
+ #
+ # q.seplist([1,2,3], lambda { q.comma_breakable }, :each) {|v| xxx v }
+ #
+ # xxx 1
+ # q.comma_breakable
+ # xxx 2
+ # q.comma_breakable
+ # xxx 3
+ #
+ # source://prettier_print//lib/prettier_print.rb#760
+ def seplist(list, sep = T.unsafe(nil), iter_method = T.unsafe(nil)); end
+
+ # The current array of contents that calls to methods that generate print tree
+ # nodes will append to.
+ #
+ # source://prettier_print//lib/prettier_print.rb#423
+ def target; end
+
+ # This adds +object+ as a text of +width+ columns in width.
+ #
+ # If +width+ is not specified, object.length is used.
+ #
+ # source://prettier_print//lib/prettier_print.rb#989
+ def text(object = T.unsafe(nil), width = T.unsafe(nil)); end
+
+ # This inserts a Trim node into the print tree which, when printed, will clear
+ # all whitespace at the end of the output buffer. This is useful for the rare
+ # case where you need to delete printed indentation and force the next node
+ # to start at the beginning of the line.
+ #
+ # source://prettier_print//lib/prettier_print.rb#828
+ def trim; end
+
+ # A convenience method used by a lot of the print tree node builders that
+ # temporarily changes the target that the builders will append to.
+ #
+ # source://prettier_print//lib/prettier_print.rb#1007
+ def with_target(target); end
+
+ private
+
+ # This method returns a boolean as to whether or not the remaining commands
+ # fit onto the remaining space on the current line. If we finish printing
+ # all of the commands or if we hit a newline, then we return true. Otherwise
+ # if we continue printing past the remaining space, we return false.
+ #
+ # @return [Boolean]
+ #
+ # source://prettier_print//lib/prettier_print.rb#1019
+ def fits?(next_commands, rest_commands, remaining); end
+
+ # source://prettier_print//lib/prettier_print.rb#1091
+ def remove_breaks_with(doc, replace); end
+
+ # Resets the group stack and target array so that this pretty printer object
+ # can continue to be used before calling flush again if desired.
+ #
+ # source://prettier_print//lib/prettier_print.rb#1085
+ def reset; end
+
+ class << self
+ # This is a convenience method which is same as follows:
+ #
+ # begin
+ # q = PrettierPrint.new(output, maxwidth, newline, &genspace)
+ # ...
+ # q.flush
+ # output
+ # end
+ #
+ # @yield [q]
+ #
+ # source://prettier_print//lib/prettier_print.rb#377
+ def format(output = T.unsafe(nil), maxwidth = T.unsafe(nil), newline = T.unsafe(nil), genspace = T.unsafe(nil), indentation = T.unsafe(nil)); end
+
+ # This is similar to PrettierPrint::format but the result has no breaks.
+ #
+ # +maxwidth+, +newline+ and +genspace+ are ignored.
+ #
+ # The invocation of +breakable+ in the block doesn't break a line and is
+ # treated as just an invocation of +text+.
+ #
+ # @yield [q]
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#156
+ def singleline_format(output = T.unsafe(nil), _maxwidth = T.unsafe(nil), _newline = T.unsafe(nil), _genspace = T.unsafe(nil)); end
+ end
+end
+
+# A node in the print tree that represents aligning nested nodes to a certain
+# prefix width or string.
+#
+# source://prettier_print//lib/prettier_print.rb#65
+class PrettierPrint::Align
+ # @return [Align] a new instance of Align
+ #
+ # source://prettier_print//lib/prettier_print.rb#68
+ def initialize(indent:, contents: T.unsafe(nil)); end
+
+ # Returns the value of attribute contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#66
+ def contents; end
+
+ # Returns the value of attribute indent.
+ #
+ # source://prettier_print//lib/prettier_print.rb#66
+ def indent; end
+
+ # source://prettier_print//lib/prettier_print.rb#73
+ def pretty_print(q); end
+end
+
+# source://prettier_print//lib/prettier_print.rb#126
+PrettierPrint::BREAKABLE_EMPTY = T.let(T.unsafe(nil), PrettierPrint::Breakable)
+
+# source://prettier_print//lib/prettier_print.rb#127
+PrettierPrint::BREAKABLE_FORCE = T.let(T.unsafe(nil), PrettierPrint::Breakable)
+
+# source://prettier_print//lib/prettier_print.rb#128
+PrettierPrint::BREAKABLE_RETURN = T.let(T.unsafe(nil), PrettierPrint::Breakable)
+
+# Below here are the most common combination of options that are created when
+# creating new breakables. They are here to cut down on some allocations.
+#
+# source://prettier_print//lib/prettier_print.rb#125
+PrettierPrint::BREAKABLE_SPACE = T.let(T.unsafe(nil), PrettierPrint::Breakable)
+
+# Since there's really no difference in these instances, just using the same
+# one saves on some allocations.
+#
+# source://prettier_print//lib/prettier_print.rb#141
+PrettierPrint::BREAK_PARENT = T.let(T.unsafe(nil), PrettierPrint::BreakParent)
+
+# A node in the print tree that forces the surrounding group to print out in
+# the "break" mode as opposed to the "flat" mode. Useful for when you need to
+# force a newline into a group.
+#
+# source://prettier_print//lib/prettier_print.rb#133
+class PrettierPrint::BreakParent
+ # source://prettier_print//lib/prettier_print.rb#134
+ def pretty_print(q); end
+end
+
+# A node in the print tree that represents a place in the buffer that the
+# content can be broken onto multiple lines.
+#
+# source://prettier_print//lib/prettier_print.rb#82
+class PrettierPrint::Breakable
+ # @return [Breakable] a new instance of Breakable
+ #
+ # source://prettier_print//lib/prettier_print.rb#85
+ def initialize(separator = T.unsafe(nil), width = T.unsafe(nil), force: T.unsafe(nil), indent: T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://prettier_print//lib/prettier_print.rb#97
+ def force?; end
+
+ # @return [Boolean]
+ #
+ # source://prettier_print//lib/prettier_print.rb#101
+ def indent?; end
+
+ # source://prettier_print//lib/prettier_print.rb#105
+ def pretty_print(q); end
+
+ # Returns the value of attribute separator.
+ #
+ # source://prettier_print//lib/prettier_print.rb#83
+ def separator; end
+
+ # Returns the value of attribute width.
+ #
+ # source://prettier_print//lib/prettier_print.rb#83
+ def width; end
+end
+
+# When building up the contents in the output buffer, it's convenient to be
+# able to trim trailing whitespace before newlines. If the output object is a
+# string or array or strings, then we can do this with some gsub calls. If
+# not, then this effectively just wraps the output object and forwards on
+# calls to <<.
+#
+# source://prettier_print//lib/prettier_print.rb#277
+module PrettierPrint::Buffer
+ class << self
+ # This is a switch for building the correct output buffer wrapper class for
+ # the given output object.
+ #
+ # source://prettier_print//lib/prettier_print.rb#336
+ def for(output); end
+ end
+end
+
+# This is an output buffer that wraps an array output object. It provides a
+# trim! method that trims off trailing whitespace from the last element in
+# the array if it's an unfrozen string using the same method as the
+# StringBuffer.
+#
+# source://prettier_print//lib/prettier_print.rb#303
+class PrettierPrint::Buffer::ArrayBuffer
+ # @return [ArrayBuffer] a new instance of ArrayBuffer
+ #
+ # source://prettier_print//lib/prettier_print.rb#306
+ def initialize(output = T.unsafe(nil)); end
+
+ # source://prettier_print//lib/prettier_print.rb#310
+ def <<(object); end
+
+ # Returns the value of attribute output.
+ #
+ # source://prettier_print//lib/prettier_print.rb#304
+ def output; end
+
+ # source://prettier_print//lib/prettier_print.rb#314
+ def trim!; end
+end
+
+# This is an output buffer that wraps a string output object. It provides a
+# trim! method that trims off trailing whitespace from the string using
+# gsub!.
+#
+# source://prettier_print//lib/prettier_print.rb#281
+class PrettierPrint::Buffer::StringBuffer
+ # @return [StringBuffer] a new instance of StringBuffer
+ #
+ # source://prettier_print//lib/prettier_print.rb#284
+ def initialize(output = T.unsafe(nil)); end
+
+ # source://prettier_print//lib/prettier_print.rb#288
+ def <<(object); end
+
+ # Returns the value of attribute output.
+ #
+ # source://prettier_print//lib/prettier_print.rb#282
+ def output; end
+
+ # source://prettier_print//lib/prettier_print.rb#292
+ def trim!; end
+end
+
+# When generating spaces after a newline for indentation, by default we
+# generate one space per character needed for indentation. You can change this
+# behavior (for instance to use tabs) by passing a different genspace
+# procedure.
+#
+# source://prettier_print//lib/prettier_print.rb#350
+PrettierPrint::DEFAULT_GENSPACE = T.let(T.unsafe(nil), Proc)
+
+# The default indentation for printing is zero, assuming that the code starts
+# at the top level. That can be changed if desired to start from a different
+# indentation level.
+#
+# source://prettier_print//lib/prettier_print.rb#366
+PrettierPrint::DEFAULT_INDENTATION = T.let(T.unsafe(nil), Integer)
+
+# When printing, you can optionally specify the value that should be used
+# whenever a group needs to be broken onto multiple lines. In this case the
+# default is \n.
+#
+# source://prettier_print//lib/prettier_print.rb#344
+PrettierPrint::DEFAULT_NEWLINE = T.let(T.unsafe(nil), String)
+
+# A node in the print tree that represents a group of items which the printer
+# should try to fit onto one line. This is the basic command to tell the
+# printer when to break. Groups are usually nested, and the printer will try
+# to fit everything on one line, but if it doesn't fit it will break the
+# outermost group first and try again. It will continue breaking groups until
+# everything fits (or there are no more groups to break).
+#
+# source://prettier_print//lib/prettier_print.rb#149
+class PrettierPrint::Group
+ # @return [Group] a new instance of Group
+ #
+ # source://prettier_print//lib/prettier_print.rb#152
+ def initialize(depth, contents: T.unsafe(nil)); end
+
+ # source://prettier_print//lib/prettier_print.rb#158
+ def break; end
+
+ # @return [Boolean]
+ #
+ # source://prettier_print//lib/prettier_print.rb#162
+ def break?; end
+
+ # Returns the value of attribute contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#150
+ def contents; end
+
+ # Returns the value of attribute depth.
+ #
+ # source://prettier_print//lib/prettier_print.rb#150
+ def depth; end
+
+ # source://prettier_print//lib/prettier_print.rb#166
+ def pretty_print(q); end
+end
+
+# A node in the print tree that represents printing one thing if the
+# surrounding group node is broken and another thing if the surrounding group
+# node is flat.
+#
+# source://prettier_print//lib/prettier_print.rb#176
+class PrettierPrint::IfBreak
+ # @return [IfBreak] a new instance of IfBreak
+ #
+ # source://prettier_print//lib/prettier_print.rb#179
+ def initialize(break_contents: T.unsafe(nil), flat_contents: T.unsafe(nil)); end
+
+ # Returns the value of attribute break_contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#177
+ def break_contents; end
+
+ # Returns the value of attribute flat_contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#177
+ def flat_contents; end
+
+ # source://prettier_print//lib/prettier_print.rb#184
+ def pretty_print(q); end
+end
+
+# A small DSL-like object used for specifying the alternative contents to be
+# printed if the surrounding group doesn't break for an IfBreak node.
+#
+# source://prettier_print//lib/prettier_print.rb#874
+class PrettierPrint::IfBreakBuilder
+ # @return [IfBreakBuilder] a new instance of IfBreakBuilder
+ #
+ # source://prettier_print//lib/prettier_print.rb#877
+ def initialize(q, flat_contents); end
+
+ # Returns the value of attribute flat_contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#875
+ def flat_contents; end
+
+ # source://prettier_print//lib/prettier_print.rb#882
+ def if_flat; end
+
+ # Returns the value of attribute q.
+ #
+ # source://prettier_print//lib/prettier_print.rb#875
+ def q; end
+end
+
+# When we already know that groups are broken, we don't actually need to track
+# the flat versions of the contents. So this builder version is effectively a
+# no-op, but we need it to maintain the same API. The only thing this can
+# impact is that if there's a forced break in the flat contents, then we need
+# to propagate that break up the whole tree.
+#
+# source://prettier_print//lib/prettier_print.rb#892
+class PrettierPrint::IfFlatIgnore
+ # @return [IfFlatIgnore] a new instance of IfFlatIgnore
+ #
+ # source://prettier_print//lib/prettier_print.rb#895
+ def initialize(q); end
+
+ # source://prettier_print//lib/prettier_print.rb#899
+ def if_flat; end
+
+ # Returns the value of attribute q.
+ #
+ # source://prettier_print//lib/prettier_print.rb#893
+ def q; end
+end
+
+# A node in the print tree that is a variant of the Align node that indents
+# its contents by one level.
+#
+# source://prettier_print//lib/prettier_print.rb#200
+class PrettierPrint::Indent
+ # @return [Indent] a new instance of Indent
+ #
+ # source://prettier_print//lib/prettier_print.rb#203
+ def initialize(contents: T.unsafe(nil)); end
+
+ # Returns the value of attribute contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#201
+ def contents; end
+
+ # source://prettier_print//lib/prettier_print.rb#207
+ def pretty_print(q); end
+end
+
+# A node in the print tree that has its own special buffer for implementing
+# content that should flush before any newline.
+#
+# Useful for implementating trailing content, as it's not always practical to
+# constantly check where the line ends to avoid accidentally printing some
+# content after a line suffix node.
+#
+# source://prettier_print//lib/prettier_print.rb#220
+class PrettierPrint::LineSuffix
+ # @return [LineSuffix] a new instance of LineSuffix
+ #
+ # source://prettier_print//lib/prettier_print.rb#225
+ def initialize(priority: T.unsafe(nil), contents: T.unsafe(nil)); end
+
+ # Returns the value of attribute contents.
+ #
+ # source://prettier_print//lib/prettier_print.rb#223
+ def contents; end
+
+ # source://prettier_print//lib/prettier_print.rb#230
+ def pretty_print(q); end
+
+ # Returns the value of attribute priority.
+ #
+ # source://prettier_print//lib/prettier_print.rb#223
+ def priority; end
+end
+
+# source://prettier_print//lib/prettier_print.rb#221
+PrettierPrint::LineSuffix::DEFAULT_PRIORITY = T.let(T.unsafe(nil), Integer)
+
+# There are two modes in printing, break and flat. When we're in break mode,
+# any lines will use their newline, any if-breaks will use their break
+# contents, etc.
+#
+# source://prettier_print//lib/prettier_print.rb#356
+PrettierPrint::MODE_BREAK = T.let(T.unsafe(nil), Integer)
+
+# This is another print mode much like MODE_BREAK. When we're in flat mode, we
+# attempt to print everything on one line until we either hit a broken group,
+# a forced line, or the maximum width.
+#
+# source://prettier_print//lib/prettier_print.rb#361
+PrettierPrint::MODE_FLAT = T.let(T.unsafe(nil), Integer)
+
+# PrettierPrint::SingleLine is used by PrettierPrint.singleline_format
+#
+# It is passed to be similar to a PrettierPrint object itself, by responding to
+# all of the same print tree node builder methods, as well as the #flush
+# method.
+#
+# The significant difference here is that there are no line breaks in the
+# output. If an IfBreak node is used, only the flat contents are printed.
+# LineSuffix nodes are printed at the end of the buffer when #flush is called.
+#
+# source://prettier_print//lib/prettier_print/single_line.rb#13
+class PrettierPrint::SingleLine
+ # Create a PrettierPrint::SingleLine object
+ #
+ # Arguments:
+ # * +output+ - String (or similar) to store rendered text. Needs to respond
+ # to '<<'.
+ # * +maxwidth+ - Argument position expected to be here for compatibility.
+ # This argument is a noop.
+ # * +newline+ - Argument position expected to be here for compatibility.
+ # This argument is a noop.
+ #
+ # @return [SingleLine] a new instance of SingleLine
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#34
+ def initialize(output, _maxwidth = T.unsafe(nil), _newline = T.unsafe(nil)); end
+
+ # Here for compatibility, does nothing.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#64
+ def break_parent; end
+
+ # Appends +separator+ to the text to be output. By default +separator+ is
+ # ' '
+ #
+ # The +width+, +indent+, and +force+ arguments are here for compatibility.
+ # They are all noop arguments.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#54
+ def breakable(separator = T.unsafe(nil), _width = T.unsafe(nil), indent: T.unsafe(nil), force: T.unsafe(nil)); end
+
+ # Appends +separator+ to the output buffer. +width+ is a noop here for
+ # compatibility.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#69
+ def fill_breakable(separator = T.unsafe(nil), _width = T.unsafe(nil)); end
+
+ # Flushes the line suffixes onto the output buffer.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#41
+ def flush; end
+
+ # Opens a block for grouping objects to be pretty printed.
+ #
+ # Arguments:
+ # * +indent+ - noop argument. Present for compatibility.
+ # * +open_obj+ - text appended before the &block. Default is ''
+ # * +close_obj+ - text appended after the &block. Default is ''
+ # * +open_width+ - noop argument. Present for compatibility.
+ # * +close_width+ - noop argument. Present for compatibility.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#90
+ def group(_indent = T.unsafe(nil), open_object = T.unsafe(nil), close_object = T.unsafe(nil), _open_width = T.unsafe(nil), _close_width = T.unsafe(nil)); end
+
+ # Effectively unnecessary, but here for compatibility.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#113
+ def if_break; end
+
+ # Also effectively unnecessary, but here for compatibility.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#118
+ def if_flat; end
+
+ # A noop that immediately yields.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#122
+ def indent; end
+
+ # Changes the target output buffer to the line suffix output buffer which
+ # will get flushed at the end of printing.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#128
+ def line_suffix; end
+
+ # A buffer output that wraps any calls to line_suffix that will be flushed
+ # at the end of printing.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#23
+ def line_suffixes; end
+
+ # Takes +indent+ arg, but does nothing with it.
+ #
+ # Yields to a block.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#137
+ def nest(_indent); end
+
+ # The output object. It stores rendered text and should respond to <<.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#15
+ def output; end
+
+ # The current array of contents that the print tree builder methods should
+ # append to.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#19
+ def target; end
+
+ # Add +object+ to the text to be output.
+ #
+ # +width+ argument is here for compatibility. It is a noop argument.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#144
+ def text(object = T.unsafe(nil), _width = T.unsafe(nil)); end
+
+ # Immediately trims the output buffer.
+ #
+ # source://prettier_print//lib/prettier_print/single_line.rb#74
+ def trim; end
+end
+
+# A class that wraps the ability to call #if_flat. The contents of the
+# #if_flat block are executed immediately, so effectively this class and the
+# #if_break method that triggers it are unnecessary, but they're here to
+# maintain compatibility.
+#
+# source://prettier_print//lib/prettier_print/single_line.rb#106
+class PrettierPrint::SingleLine::IfBreakBuilder
+ # source://prettier_print//lib/prettier_print/single_line.rb#107
+ def if_flat; end
+end
+
+# Since all of the instances here are the same, we can reuse the same one to
+# cut down on allocations.
+#
+# source://prettier_print//lib/prettier_print.rb#270
+PrettierPrint::TRIM = T.let(T.unsafe(nil), PrettierPrint::Trim)
+
+# A node in the print tree that represents plain content that cannot be broken
+# up (by default this assumes strings, but it can really be anything).
+#
+# source://prettier_print//lib/prettier_print.rb#239
+class PrettierPrint::Text
+ # @return [Text] a new instance of Text
+ #
+ # source://prettier_print//lib/prettier_print.rb#242
+ def initialize; end
+
+ # source://prettier_print//lib/prettier_print.rb#247
+ def add(object: T.unsafe(nil), width: T.unsafe(nil)); end
+
+ # Returns the value of attribute objects.
+ #
+ # source://prettier_print//lib/prettier_print.rb#240
+ def objects; end
+
+ # source://prettier_print//lib/prettier_print.rb#252
+ def pretty_print(q); end
+
+ # Returns the value of attribute width.
+ #
+ # source://prettier_print//lib/prettier_print.rb#240
+ def width; end
+end
+
+# A node in the print tree that represents trimming all of the indentation of
+# the current line, in the rare case that you need to ignore the indentation
+# that you've already created. This node should be placed after a Breakable.
+#
+# source://prettier_print//lib/prettier_print.rb#262
+class PrettierPrint::Trim
+ # source://prettier_print//lib/prettier_print.rb#263
+ def pretty_print(q); end
+end
diff --git a/2023/sorbet/rbi/gems/prism@0.19.0.rbi b/2023/sorbet/rbi/gems/prism@0.19.0.rbi
new file mode 100644
index 0000000..901807f
--- /dev/null
+++ b/2023/sorbet/rbi/gems/prism@0.19.0.rbi
@@ -0,0 +1,29883 @@
+# 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`.
+
+# =begin
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/rbi/prism.rbi.erb
+# if you are looking to modify the template
+# =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) -> ParseResult
+ #
+ # Returns a parse result whose value is an array of tokens that closely
+ # resembles the return value of Ripper::lex. The main difference is that the
+ # `:on_sp` token is not emitted.
+ #
+ # For supported options, see Prism::parse.
+ #
+ # source://prism//lib/prism.rb#46
+ 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#56
+ 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#64
+ def load(source, serialized); end
+
+ # Mirror the Prism.parse API by using the serialization API.
+ def parse(*_arg0); end
+
+ # Mirror the Prism.parse_comments API by using the serialization API.
+ def parse_comments(*_arg0); end
+
+ # :call-seq:
+ # Prism::parse_failure?(source, **options) -> bool
+ #
+ # Returns true if the source parses with errors.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism.rb#72
+ def parse_failure?(source, **options); end
+
+ # Mirror the Prism.parse_file API by using the serialization API. This uses
+ # native strings instead of Ruby strings because it allows us to use mmap when
+ # it is available.
+ def parse_file(*_arg0); end
+
+ # Mirror the Prism.parse_file_comments API by using the serialization
+ # API. This uses native strings instead of Ruby strings because it allows us
+ # to use mmap when it is available.
+ def parse_file_comments(*_arg0); end
+
+ # :call-seq:
+ # Prism::parse_file_failure?(filepath, **options) -> bool
+ #
+ # Returns true if the file at filepath parses with errors.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism.rb#80
+ def parse_file_failure?(filepath, **options); end
+
+ # Mirror the Prism.parse_file_success? API by using the serialization API.
+ #
+ # @return [Boolean]
+ def parse_file_success?(*_arg0); end
+
+ # Mirror the Prism.parse_lex API by using the serialization API.
+ def parse_lex(*_arg0); end
+
+ # Mirror the Prism.parse_lex_file API by using the serialization API.
+ def parse_lex_file(*_arg0); end
+
+ # Mirror the Prism.parse_success? API by using the serialization API.
+ #
+ # @return [Boolean]
+ def parse_success?(*_arg0); end
+ end
+end
+
+# Represents the use of the `alias` keyword to alias a global variable.
+#
+# alias $foo $bar
+# ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#52
+class Prism::AliasGlobalVariableNode < ::Prism::Node
+ # def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
+ #
+ # source://prism//lib/prism/node.rb#63
+ sig do
+ params(
+ new_name: Prism::Node,
+ old_name: Prism::Node,
+ keyword_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(new_name, old_name, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#71
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#76
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#86
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#81
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AliasGlobalVariableNode
+ #
+ # source://prism//lib/prism/node.rb#91
+ sig { params(params: T.untyped).returns(Prism::AliasGlobalVariableNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#76
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#104
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#114
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#109
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#60
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader new_name: Node
+ #
+ # source://prism//lib/prism/node.rb#54
+ sig { returns(Prism::Node) }
+ def new_name; end
+
+ # attr_reader old_name: Node
+ #
+ # source://prism//lib/prism/node.rb#57
+ 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#138
+ 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#148
+ 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#157
+class Prism::AliasMethodNode < ::Prism::Node
+ # def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [AliasMethodNode] a new instance of AliasMethodNode
+ #
+ # source://prism//lib/prism/node.rb#168
+ sig do
+ params(
+ new_name: Prism::Node,
+ old_name: Prism::Node,
+ keyword_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(new_name, old_name, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#176
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#181
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#191
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#186
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AliasMethodNode
+ #
+ # source://prism//lib/prism/node.rb#196
+ sig { params(params: T.untyped).returns(Prism::AliasMethodNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#181
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#209
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#219
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#214
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#165
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader new_name: Node
+ #
+ # source://prism//lib/prism/node.rb#159
+ sig { returns(Prism::Node) }
+ def new_name; end
+
+ # attr_reader old_name: Node
+ #
+ # source://prism//lib/prism/node.rb#162
+ 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#243
+ 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#253
+ def type; end
+ end
+end
+
+# Represents an alternation pattern in pattern matching.
+#
+# foo => bar | baz
+# ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#262
+class Prism::AlternationPatternNode < ::Prism::Node
+ # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [AlternationPatternNode] a new instance of AlternationPatternNode
+ #
+ # source://prism//lib/prism/node.rb#273
+ sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(left, right, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#281
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#286
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#296
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#291
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AlternationPatternNode
+ #
+ # source://prism//lib/prism/node.rb#301
+ sig { params(params: T.untyped).returns(Prism::AlternationPatternNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#286
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#314
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#324
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node
+ #
+ # source://prism//lib/prism/node.rb#264
+ sig { returns(Prism::Node) }
+ def left; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#319
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#270
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader right: Node
+ #
+ # source://prism//lib/prism/node.rb#267
+ 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#348
+ 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#358
+ def type; end
+ end
+end
+
+# Represents the use of the `&&` operator or the `and` keyword.
+#
+# left and right
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#367
+class Prism::AndNode < ::Prism::Node
+ # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [AndNode] a new instance of AndNode
+ #
+ # source://prism//lib/prism/node.rb#378
+ sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(left, right, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#386
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#391
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#401
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#396
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AndNode
+ #
+ # source://prism//lib/prism/node.rb#406
+ sig { params(params: T.untyped).returns(Prism::AndNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#391
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#419
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#429
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node
+ #
+ # source://prism//lib/prism/node.rb#369
+ sig { returns(Prism::Node) }
+ def left; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#424
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#375
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader right: Node
+ #
+ # source://prism//lib/prism/node.rb#372
+ 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#453
+ 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#463
+ 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#472
+class Prism::ArgumentsNode < ::Prism::Node
+ # def initialize: (flags: Integer, arguments: Array[Node], location: Location) -> void
+ #
+ # @return [ArgumentsNode] a new instance of ArgumentsNode
+ #
+ # source://prism//lib/prism/node.rb#480
+ sig { params(flags: Integer, arguments: T::Array[Prism::Node], location: Prism::Location).void }
+ def initialize(flags, arguments, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#487
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#477
+ sig { returns(T::Array[Prism::Node]) }
+ def arguments; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#492
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#502
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#497
+ def compact_child_nodes; end
+
+ # def contains_keyword_splat?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#524
+ sig { returns(T::Boolean) }
+ def contains_keyword_splat?; end
+
+ # def copy: (**params) -> ArgumentsNode
+ #
+ # source://prism//lib/prism/node.rb#507
+ sig { params(params: T.untyped).returns(Prism::ArgumentsNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#492
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#519
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#529
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#551
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#474
+ 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#561
+ def type; end
+ end
+end
+
+# Flags for arguments nodes.
+#
+# source://prism//lib/prism/node.rb#17277
+module Prism::ArgumentsNodeFlags; end
+
+# if arguments contain keyword splat
+#
+# source://prism//lib/prism/node.rb#17279
+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#571
+class Prism::ArrayNode < ::Prism::Node
+ # def initialize: (flags: Integer, elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+ #
+ # @return [ArrayNode] a new instance of ArrayNode
+ #
+ # source://prism//lib/prism/node.rb#585
+ 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
+ ).void
+ end
+ def initialize(flags, elements, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#594
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#599
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#643
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#582
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#609
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#604
+ def compact_child_nodes; end
+
+ # def contains_splat?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#633
+ sig { returns(T::Boolean) }
+ def contains_splat?; end
+
+ # def copy: (**params) -> ArrayNode
+ #
+ # source://prism//lib/prism/node.rb#614
+ sig { params(params: T.untyped).returns(Prism::ArrayNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#599
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#628
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader elements: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#576
+ sig { returns(T::Array[Prism::Node]) }
+ def elements; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#648
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#638
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#579
+ 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#672
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#573
+ 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#682
+ def type; end
+ end
+end
+
+# Flags for array nodes.
+#
+# source://prism//lib/prism/node.rb#17283
+module Prism::ArrayNodeFlags; end
+
+# if array contains splat nodes
+#
+# source://prism//lib/prism/node.rb#17285
+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#703
+class Prism::ArrayPatternNode < ::Prism::Node
+ # def initialize: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+ #
+ # @return [ArrayPatternNode] a new instance of ArrayPatternNode
+ #
+ # source://prism//lib/prism/node.rb#723
+ 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
+ ).void
+ end
+ def initialize(constant, requireds, rest, posts, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#734
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#739
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#785
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#720
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#754
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#744
+ def compact_child_nodes; end
+
+ # attr_reader constant: Node?
+ #
+ # source://prism//lib/prism/node.rb#705
+ sig { returns(T.nilable(Prism::Node)) }
+ def constant; end
+
+ # def copy: (**params) -> ArrayPatternNode
+ #
+ # source://prism//lib/prism/node.rb#759
+ sig { params(params: T.untyped).returns(Prism::ArrayPatternNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#739
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#775
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#790
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#780
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#717
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader posts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#714
+ sig { returns(T::Array[Prism::Node]) }
+ def posts; end
+
+ # attr_reader requireds: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#708
+ sig { returns(T::Array[Prism::Node]) }
+ def requireds; end
+
+ # attr_reader rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#711
+ 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#825
+ 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#835
+ def type; end
+ end
+end
+
+# Represents a hash key/value pair.
+#
+# { a => b }
+# ^^^^^^
+#
+# source://prism//lib/prism/node.rb#844
+class Prism::AssocNode < ::Prism::Node
+ # def initialize: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> void
+ #
+ # @return [AssocNode] a new instance of AssocNode
+ #
+ # source://prism//lib/prism/node.rb#855
+ sig do
+ params(
+ key: Prism::Node,
+ value: T.nilable(Prism::Node),
+ operator_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(key, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#863
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#868
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#881
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#873
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AssocNode
+ #
+ # source://prism//lib/prism/node.rb#886
+ sig { params(params: T.untyped).returns(Prism::AssocNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#868
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#899
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#909
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader key: Node
+ #
+ # source://prism//lib/prism/node.rb#846
+ sig { returns(Prism::Node) }
+ def key; end
+
+ # def operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#904
+ sig { returns(T.nilable(String)) }
+ def operator; end
+
+ # attr_reader operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#852
+ 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#937
+ def type; end
+
+ # attr_reader value: Node?
+ #
+ # source://prism//lib/prism/node.rb#849
+ 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#947
+ def type; end
+ end
+end
+
+# Represents a splat in a hash literal.
+#
+# { **foo }
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#956
+class Prism::AssocSplatNode < ::Prism::Node
+ # def initialize: (value: Node?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [AssocSplatNode] a new instance of AssocSplatNode
+ #
+ # source://prism//lib/prism/node.rb#964
+ sig { params(value: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#971
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#976
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#988
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#981
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> AssocSplatNode
+ #
+ # source://prism//lib/prism/node.rb#993
+ sig { params(params: T.untyped).returns(Prism::AssocSplatNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#976
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1005
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1015
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1010
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#961
+ 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#1041
+ def type; end
+
+ # attr_reader value: Node?
+ #
+ # source://prism//lib/prism/node.rb#958
+ 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#1051
+ def type; end
+ end
+end
+
+Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
+
+# Represents reading a reference to a field in the previous match.
+#
+# $'
+# ^^
+#
+# source://prism//lib/prism/node.rb#1060
+class Prism::BackReferenceReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
+ #
+ # source://prism//lib/prism/node.rb#1065
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1071
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1076
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1086
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1081
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BackReferenceReadNode
+ #
+ # source://prism//lib/prism/node.rb#1091
+ sig { params(params: T.untyped).returns(Prism::BackReferenceReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1076
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1102
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1107
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#1062
+ 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#1127
+ 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#1137
+ 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#13
+class Prism::BasicVisitor
+ # Calls `accept` on the given node if it is not `nil`, which in turn should
+ # call back into this visitor by calling the appropriate `visit_*` method.
+ #
+ # source://prism//lib/prism/visitor.rb#16
+ 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#21
+ 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#26
+ 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#1148
+class Prism::BeginNode < ::Prism::Node
+ # def initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void
+ #
+ # @return [BeginNode] a new instance of BeginNode
+ #
+ # source://prism//lib/prism/node.rb#1168
+ 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
+ ).void
+ end
+ def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1179
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def begin_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#1229
+ sig { returns(T.nilable(String)) }
+ def begin_keyword; end
+
+ # attr_reader begin_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1150
+ sig { returns(T.nilable(Prism::Location)) }
+ def begin_keyword_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1188
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1203
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1193
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BeginNode
+ #
+ # source://prism//lib/prism/node.rb#1208
+ sig { params(params: T.untyped).returns(Prism::BeginNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1188
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1224
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader else_clause: ElseNode?
+ #
+ # source://prism//lib/prism/node.rb#1159
+ sig { returns(T.nilable(Prism::ElseNode)) }
+ def else_clause; end
+
+ # def end_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#1234
+ sig { returns(T.nilable(String)) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1165
+ sig { returns(T.nilable(Prism::Location)) }
+ def end_keyword_loc; end
+
+ # attr_reader ensure_clause: EnsureNode?
+ #
+ # source://prism//lib/prism/node.rb#1162
+ sig { returns(T.nilable(Prism::EnsureNode)) }
+ def ensure_clause; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1239
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader rescue_clause: RescueNode?
+ #
+ # source://prism//lib/prism/node.rb#1156
+ sig { returns(T.nilable(Prism::RescueNode)) }
+ def rescue_clause; end
+
+ # source://prism//lib/prism/node.rb#1183
+ def set_newline_flag(newline_marked); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#1153
+ 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#1284
+ 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#1294
+ def type; end
+ end
+end
+
+# Represents block method arguments.
+#
+# bar(&args)
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1303
+class Prism::BlockArgumentNode < ::Prism::Node
+ # def initialize: (expression: Node?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [BlockArgumentNode] a new instance of BlockArgumentNode
+ #
+ # source://prism//lib/prism/node.rb#1311
+ sig { params(expression: T.nilable(Prism::Node), operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(expression, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1318
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1323
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1335
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1328
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BlockArgumentNode
+ #
+ # source://prism//lib/prism/node.rb#1340
+ sig { params(params: T.untyped).returns(Prism::BlockArgumentNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1323
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1352
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader expression: Node?
+ #
+ # source://prism//lib/prism/node.rb#1305
+ sig { returns(T.nilable(Prism::Node)) }
+ def expression; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1362
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1357
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1308
+ 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#1388
+ 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#1398
+ def type; end
+ end
+end
+
+# Represents a block local variable.
+#
+# a { |; b| }
+# ^
+#
+# source://prism//lib/prism/node.rb#1407
+class Prism::BlockLocalVariableNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
+ #
+ # source://prism//lib/prism/node.rb#1412
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1418
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1423
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1433
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1428
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BlockLocalVariableNode
+ #
+ # source://prism//lib/prism/node.rb#1438
+ sig { params(params: T.untyped).returns(Prism::BlockLocalVariableNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1423
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1449
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1454
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#1409
+ 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#1474
+ 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#1484
+ def type; end
+ end
+end
+
+# Represents a block of ruby code.
+#
+# [1, 2, 3].each { |i| puts x }
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1493
+class Prism::BlockNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], locals_body_index: Integer, parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+ #
+ # @return [BlockNode] a new instance of BlockNode
+ #
+ # source://prism//lib/prism/node.rb#1513
+ sig do
+ params(
+ locals: T::Array[Symbol],
+ locals_body_index: Integer,
+ 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(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1524
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#1504
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1529
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1573
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1510
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1542
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1534
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BlockNode
+ #
+ # source://prism//lib/prism/node.rb#1547
+ sig { params(params: T.untyped).returns(Prism::BlockNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1529
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1563
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1578
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#1495
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # attr_reader locals_body_index: Integer
+ #
+ # source://prism//lib/prism/node.rb#1498
+ sig { returns(Integer) }
+ def locals_body_index; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1568
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1507
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader parameters: Node?
+ #
+ # source://prism//lib/prism/node.rb#1501
+ 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#1613
+ 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#1623
+ 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#1633
+class Prism::BlockParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [BlockParameterNode] a new instance of BlockParameterNode
+ #
+ # source://prism//lib/prism/node.rb#1644
+ sig do
+ params(
+ name: T.nilable(Symbol),
+ name_loc: T.nilable(Prism::Location),
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1652
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1657
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1667
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1662
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BlockParameterNode
+ #
+ # source://prism//lib/prism/node.rb#1672
+ sig { params(params: T.untyped).returns(Prism::BlockParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1657
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1685
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1695
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol?
+ #
+ # source://prism//lib/prism/node.rb#1635
+ sig { returns(T.nilable(Symbol)) }
+ def name; end
+
+ # attr_reader name_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1638
+ sig { returns(T.nilable(Prism::Location)) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1690
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1641
+ 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#1721
+ 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#1731
+ 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#1744
+class Prism::BlockParametersNode < ::Prism::Node
+ # def initialize: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+ #
+ # @return [BlockParametersNode] a new instance of BlockParametersNode
+ #
+ # source://prism//lib/prism/node.rb#1758
+ sig do
+ params(
+ parameters: T.nilable(Prism::ParametersNode),
+ locals: T::Array[Prism::Node],
+ opening_loc: T.nilable(Prism::Location),
+ closing_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(parameters, locals, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1767
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1772
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#1814
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1755
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1785
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1777
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BlockParametersNode
+ #
+ # source://prism//lib/prism/node.rb#1790
+ sig { params(params: T.untyped).returns(Prism::BlockParametersNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1772
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1804
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1819
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1749
+ sig { returns(T::Array[Prism::Node]) }
+ def locals; end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#1809
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1752
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader parameters: ParametersNode?
+ #
+ # source://prism//lib/prism/node.rb#1746
+ 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#1847
+ 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#1857
+ def type; end
+ end
+end
+
+# Represents the use of the `break` keyword.
+#
+# break foo
+# ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1866
+class Prism::BreakNode < ::Prism::Node
+ # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [BreakNode] a new instance of BreakNode
+ #
+ # source://prism//lib/prism/node.rb#1874
+ sig do
+ params(
+ arguments: T.nilable(Prism::ArgumentsNode),
+ keyword_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(arguments, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#1881
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#1868
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1886
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#1898
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#1891
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> BreakNode
+ #
+ # source://prism//lib/prism/node.rb#1903
+ sig { params(params: T.untyped).returns(Prism::BreakNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#1886
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#1915
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#1925
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#1920
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1871
+ 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#1951
+ 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#1961
+ def type; end
+ end
+end
+
+# Represents the use of the `&&=` operator on a call.
+#
+# foo.bar &&= value
+# ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#1970
+class Prism::CallAndWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [CallAndWriteNode] a new instance of CallAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#1996
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2009
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2065
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2070
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1978
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2014
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2027
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2019
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CallAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#2032
+ sig { params(params: T.untyped).returns(Prism::CallAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2014
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2050
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2085
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def message: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2075
+ sig { returns(T.nilable(String)) }
+ def message; end
+
+ # attr_reader message_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#1981
+ sig { returns(T.nilable(Prism::Location)) }
+ def message_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#2080
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#1990
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader read_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#1984
+ sig { returns(Symbol) }
+ def read_name; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#1975
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2055
+ 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#2119
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#1993
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2060
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ # attr_reader write_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#1987
+ sig { returns(Symbol) }
+ def write_name; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#1972
+ 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#2129
+ 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#2153
+class Prism::CallNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, location: Location) -> void
+ #
+ # @return [CallNode] a new instance of CallNode
+ #
+ # source://prism//lib/prism/node.rb#2182
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2196
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#2173
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2254
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#2179
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2259
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2161
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2201
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2274
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2176
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2215
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2206
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CallNode
+ #
+ # source://prism//lib/prism/node.rb#2220
+ sig { params(params: T.untyped).returns(Prism::CallNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2201
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2239
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2279
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def message: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2264
+ sig { returns(T.nilable(String)) }
+ def message; end
+
+ # attr_reader message_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2167
+ sig { returns(T.nilable(Prism::Location)) }
+ def message_loc; end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2164
+ sig { returns(Symbol) }
+ def name; end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2269
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2170
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#2158
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2244
+ 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#2323
+ def type; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2249
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#2155
+ 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#2333
+ def type; end
+ end
+end
+
+# Flags for call nodes.
+#
+# source://prism//lib/prism/node.rb#17289
+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#17297
+Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
+
+# &. operator
+#
+# source://prism//lib/prism/node.rb#17291
+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#17294
+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#2342
+class Prism::CallOperatorWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#2371
+ 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: Symbol,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2385
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2442
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2447
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2350
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2390
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2403
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2395
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CallOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#2408
+ sig { params(params: T.untyped).returns(Prism::CallOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2390
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2427
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2457
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def message: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#2452
+ sig { returns(T.nilable(String)) }
+ def message; end
+
+ # attr_reader message_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#2353
+ sig { returns(T.nilable(Prism::Location)) }
+ def message_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2362
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2365
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader read_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2356
+ sig { returns(Symbol) }
+ def read_name; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#2347
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2432
+ 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#2492
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#2368
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2437
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ # attr_reader write_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2359
+ sig { returns(Symbol) }
+ def write_name; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#2344
+ 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#2502
+ def type; end
+ end
+end
+
+# Represents the use of the `||=` operator on a call.
+#
+# foo.bar ||= value
+# ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2511
+class Prism::CallOrWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [CallOrWriteNode] a new instance of CallOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#2537
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2550
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2606
+ sig { returns(T::Boolean) }
+ def attribute_write?; 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#2519
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2555
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2568
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2560
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CallOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#2573
+ sig { params(params: T.untyped).returns(Prism::CallOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2555
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2591
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2626
+ def inspect(inspector = T.unsafe(nil)); 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#2522
+ sig { returns(T.nilable(Prism::Location)) }
+ def message_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#2621
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2531
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader read_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2525
+ sig { returns(Symbol) }
+ def read_name; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#2516
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2596
+ 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#2660
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#2534
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2601
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ # attr_reader write_name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2528
+ sig { returns(Symbol) }
+ def write_name; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#2513
+ 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#2670
+ 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#2687
+class Prism::CallTargetNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location) -> void
+ #
+ # @return [CallTargetNode] a new instance of CallTargetNode
+ #
+ # source://prism//lib/prism/node.rb#2704
+ sig do
+ params(
+ flags: Integer,
+ receiver: Prism::Node,
+ call_operator_loc: Prism::Location,
+ name: Symbol,
+ message_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, name, message_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2714
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2764
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # def call_operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#2769
+ sig { returns(String) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2695
+ sig { returns(Prism::Location) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2719
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2729
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2724
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CallTargetNode
+ #
+ # source://prism//lib/prism/node.rb#2734
+ sig { params(params: T.untyped).returns(Prism::CallTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2719
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2749
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2779
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def message: () -> String
+ #
+ # source://prism//lib/prism/node.rb#2774
+ sig { returns(String) }
+ def message; end
+
+ # attr_reader message_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2701
+ sig { returns(Prism::Location) }
+ def message_loc; end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#2698
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader receiver: Node
+ #
+ # source://prism//lib/prism/node.rb#2692
+ sig { returns(Prism::Node) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2754
+ 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#2805
+ def type; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#2759
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#2689
+ 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#2815
+ def type; end
+ end
+end
+
+# Represents assigning to a local variable in pattern matching.
+#
+# foo => [bar => baz]
+# ^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#2824
+class Prism::CapturePatternNode < ::Prism::Node
+ # def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [CapturePatternNode] a new instance of CapturePatternNode
+ #
+ # source://prism//lib/prism/node.rb#2835
+ sig do
+ params(
+ value: Prism::Node,
+ target: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(value, target, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2843
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2848
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2858
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2853
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> CapturePatternNode
+ #
+ # source://prism//lib/prism/node.rb#2863
+ sig { params(params: T.untyped).returns(Prism::CapturePatternNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2848
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2876
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#2886
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#2881
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2832
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader target: Node
+ #
+ # source://prism//lib/prism/node.rb#2829
+ 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#2910
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#2826
+ 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#2920
+ 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#2931
+class Prism::CaseMatchNode < ::Prism::Node
+ # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+ #
+ # @return [CaseMatchNode] a new instance of CaseMatchNode
+ #
+ # source://prism//lib/prism/node.rb#2948
+ 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
+ ).void
+ end
+ def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#2958
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def case_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3002
+ sig { returns(String) }
+ def case_keyword; end
+
+ # attr_reader case_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2942
+ sig { returns(Prism::Location) }
+ def case_keyword_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2963
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#2977
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2968
+ def compact_child_nodes; end
+
+ # attr_reader conditions: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#2936
+ sig { returns(T::Array[Prism::Node]) }
+ def conditions; end
+
+ # attr_reader consequent: ElseNode?
+ #
+ # source://prism//lib/prism/node.rb#2939
+ sig { returns(T.nilable(Prism::ElseNode)) }
+ def consequent; end
+
+ # def copy: (**params) -> CaseMatchNode
+ #
+ # source://prism//lib/prism/node.rb#2982
+ sig { params(params: T.untyped).returns(Prism::CaseMatchNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#2963
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#2997
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3007
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#2945
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3012
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader predicate: Node?
+ #
+ # source://prism//lib/prism/node.rb#2933
+ 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#3046
+ 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#3056
+ def type; end
+ end
+end
+
+# Represents the use of a case statement.
+#
+# case true
+# when false
+# end
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3067
+class Prism::CaseNode < ::Prism::Node
+ # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+ #
+ # @return [CaseNode] a new instance of CaseNode
+ #
+ # source://prism//lib/prism/node.rb#3084
+ 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
+ ).void
+ end
+ def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3094
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def case_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3138
+ sig { returns(String) }
+ def case_keyword; end
+
+ # attr_reader case_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3078
+ sig { returns(Prism::Location) }
+ def case_keyword_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3099
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3113
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3104
+ def compact_child_nodes; end
+
+ # attr_reader conditions: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3072
+ sig { returns(T::Array[Prism::Node]) }
+ def conditions; end
+
+ # attr_reader consequent: ElseNode?
+ #
+ # source://prism//lib/prism/node.rb#3075
+ sig { returns(T.nilable(Prism::ElseNode)) }
+ def consequent; end
+
+ # def copy: (**params) -> CaseNode
+ #
+ # source://prism//lib/prism/node.rb#3118
+ sig { params(params: T.untyped).returns(Prism::CaseNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3099
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3133
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3143
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3081
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3148
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader predicate: Node?
+ #
+ # source://prism//lib/prism/node.rb#3069
+ 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#3182
+ 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#3192
+ def type; end
+ end
+end
+
+# Represents a class declaration involving the `class` keyword.
+#
+# class Foo end
+# ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3201
+class Prism::ClassNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
+ #
+ # @return [ClassNode] a new instance of ClassNode
+ #
+ # source://prism//lib/prism/node.rb#3227
+ 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
+ ).void
+ end
+ def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3240
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#3218
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3245
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def class_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3287
+ sig { returns(String) }
+ def class_keyword; end
+
+ # attr_reader class_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3206
+ sig { returns(Prism::Location) }
+ def class_keyword_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3259
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3250
+ def compact_child_nodes; end
+
+ # attr_reader constant_path: Node
+ #
+ # source://prism//lib/prism/node.rb#3209
+ sig { returns(Prism::Node) }
+ def constant_path; end
+
+ # def copy: (**params) -> ClassNode
+ #
+ # source://prism//lib/prism/node.rb#3264
+ sig { params(params: T.untyped).returns(Prism::ClassNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3245
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3282
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3297
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3221
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def inheritance_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#3292
+ sig { returns(T.nilable(String)) }
+ def inheritance_operator; end
+
+ # attr_reader inheritance_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#3212
+ sig { returns(T.nilable(Prism::Location)) }
+ def inheritance_operator_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3302
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#3203
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3224
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader superclass: Node?
+ #
+ # source://prism//lib/prism/node.rb#3215
+ 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#3340
+ 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#3350
+ 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#3359
+class Prism::ClassVariableAndWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3373
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3382
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3387
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3397
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3392
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3402
+ sig { params(params: T.untyped).returns(Prism::ClassVariableAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3387
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3416
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3426
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3361
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3364
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3421
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3367
+ 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#3450
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#3370
+ 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#3460
+ 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#3469
+class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+ #
+ # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3486
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ operator: Symbol,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3496
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3501
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3511
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3506
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3516
+ sig { params(params: T.untyped).returns(Prism::ClassVariableOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3501
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3531
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3536
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3471
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3474
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3483
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3477
+ 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#3561
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#3480
+ 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#3571
+ 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#3580
+class Prism::ClassVariableOrWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3594
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3603
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3608
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3618
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3613
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3623
+ sig { params(params: T.untyped).returns(Prism::ClassVariableOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3608
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3637
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3647
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3582
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3585
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#3642
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3588
+ 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#3671
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#3591
+ 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#3681
+ def type; end
+ end
+end
+
+# Represents referencing a class variable.
+#
+# @@foo
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#3690
+class Prism::ClassVariableReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#3695
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3701
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3706
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3716
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3711
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#3721
+ sig { params(params: T.untyped).returns(Prism::ClassVariableReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3706
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3732
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3737
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3692
+ 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#3757
+ 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#3767
+ 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#3776
+class Prism::ClassVariableTargetNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#3781
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3787
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3792
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3802
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3797
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#3807
+ sig { params(params: T.untyped).returns(Prism::ClassVariableTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3792
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3818
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3823
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3778
+ 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#3843
+ 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#3853
+ def type; end
+ end
+end
+
+# Represents writing to a class variable.
+#
+# @@foo = 1
+# ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3862
+class Prism::ClassVariableWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location) -> void
+ #
+ # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3876
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ value: Prism::Node,
+ operator_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3885
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3890
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#3900
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#3895
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ClassVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3905
+ sig { params(params: T.untyped).returns(Prism::ClassVariableWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#3890
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#3919
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#3929
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3864
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3867
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#3924
+ sig { returns(T.nilable(String)) }
+ def operator; end
+
+ # attr_reader operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#3873
+ 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#3953
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#3870
+ 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#3963
+ 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#228
+class Prism::Comment
+ # Create a new comment object with the given location.
+ #
+ # @return [Comment] a new instance of Comment
+ #
+ # source://prism//lib/prism/parse_result.rb#233
+ def initialize(location); end
+
+ # Implement the hash pattern matching interface for Comment.
+ #
+ # source://prism//lib/prism/parse_result.rb#238
+ def deconstruct_keys(keys); end
+
+ # The location of this comment in the source.
+ #
+ # source://prism//lib/prism/parse_result.rb#230
+ sig { returns(Prism::Location) }
+ def location; end
+
+ sig { returns(T::Boolean) }
+ def trailing?; end
+end
+
+# A compiler is a visitor that returns the value of each node as it visits.
+# This is as opposed to a visitor which will only walk the tree. This can be
+# useful when you are trying to compile a tree into a different format.
+#
+# For example, to build a representation of the tree as s-expressions, you
+# could write:
+#
+# class SExpressions < Prism::Compiler
+# def visit_arguments_node(node) = [:arguments, super]
+# def visit_call_node(node) = [:call, super]
+# def visit_integer_node(node) = [:integer]
+# def visit_program_node(node) = [:program, super]
+# end
+#
+# Prism.parse("1 + 2").value.accept(SExpressions.new)
+# # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
+#
+# source://prism//lib/prism/compiler.rb#26
+class Prism::Compiler
+ # Visit an individual node.
+ #
+ # source://prism//lib/prism/compiler.rb#28
+ def visit(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AliasGlobalVariableNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_alias_global_variable_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AliasMethodNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_alias_method_node(node); end
+
+ # Visit a list of nodes.
+ #
+ # source://prism//lib/prism/compiler.rb#33
+ def visit_all(nodes); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AlternationPatternNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_alternation_pattern_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AndNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_and_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ArgumentsNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_arguments_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ArrayNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_array_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ArrayPatternNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_array_pattern_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AssocNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_assoc_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a AssocSplatNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_assoc_splat_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BackReferenceReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_back_reference_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BeginNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_begin_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BlockArgumentNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_block_argument_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BlockLocalVariableNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_block_local_variable_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BlockNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_block_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BlockParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_block_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BlockParametersNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_block_parameters_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a BreakNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_break_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CallAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_call_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CallNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_call_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CallOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_call_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CallOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_call_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CallTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_call_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CapturePatternNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_capture_pattern_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CaseMatchNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_case_match_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a CaseNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_case_node(node); end
+
+ # Visit the child nodes of the given node.
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_child_nodes(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ClassVariableWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_class_variable_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantPathWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_path_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ConstantWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_constant_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a DefNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_def_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a DefinedNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_defined_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ElseNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_else_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a EmbeddedStatementsNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_embedded_statements_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a EmbeddedVariableNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_embedded_variable_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a EnsureNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_ensure_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a FalseNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_false_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a FindPatternNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_find_pattern_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a FlipFlopNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_flip_flop_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a FloatNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_float_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ForNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_for_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ForwardingArgumentsNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_forwarding_arguments_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ForwardingParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_forwarding_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ForwardingSuperNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_forwarding_super_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a GlobalVariableWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_global_variable_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a HashNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_hash_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a HashPatternNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_hash_pattern_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IfNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_if_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ImaginaryNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_imaginary_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ImplicitNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_implicit_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ImplicitRestNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_implicit_rest_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_in_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IndexAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_index_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IndexOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_index_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IndexOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_index_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IndexTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_index_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InstanceVariableWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_instance_variable_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a IntegerNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_integer_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InterpolatedMatchLastLineNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_interpolated_match_last_line_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InterpolatedRegularExpressionNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InterpolatedStringNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_interpolated_string_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InterpolatedSymbolNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_interpolated_symbol_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a InterpolatedXStringNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_interpolated_x_string_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a KeywordHashNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_keyword_hash_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a KeywordRestParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LambdaNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_lambda_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_and_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_operator_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_or_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a LocalVariableWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_local_variable_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MatchLastLineNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_match_last_line_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MatchPredicateNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_match_predicate_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MatchRequiredNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_match_required_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MatchWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_match_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MissingNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_missing_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ModuleNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_module_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MultiTargetNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_multi_target_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a MultiWriteNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_multi_write_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a NextNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_next_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a NilNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_nil_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a NoKeywordsParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_no_keywords_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a NumberedParametersNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_numbered_parameters_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a NumberedReferenceReadNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_numbered_reference_read_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a OptionalKeywordParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a OptionalParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_optional_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a OrNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_or_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ParametersNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_parameters_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ParenthesesNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_parentheses_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a PinnedExpressionNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_pinned_expression_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a PinnedVariableNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_pinned_variable_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a PostExecutionNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_post_execution_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a PreExecutionNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_pre_execution_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ProgramNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_program_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RangeNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_range_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RationalNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_rational_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RedoNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_redo_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RegularExpressionNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_regular_expression_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RequiredKeywordParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_required_keyword_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RequiredParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_required_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RescueModifierNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_rescue_modifier_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RescueNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_rescue_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RestParameterNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_rest_parameter_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a RetryNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_retry_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a ReturnNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_return_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SelfNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_self_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SingletonClassNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_singleton_class_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SourceEncodingNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_source_encoding_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SourceFileNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_source_file_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SourceLineNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_source_line_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SplatNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_splat_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a StatementsNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_statements_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a StringNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_string_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SuperNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_super_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a SymbolNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_symbol_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a TrueNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_true_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a UndefNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_undef_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a UnlessNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_unless_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a UntilNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_until_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a WhenNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_when_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a WhileNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_while_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a XStringNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_x_string_node(node); end
+
+ # Visit the child nodes of the given node.
+ # Compile a YieldNode node
+ #
+ # source://prism//lib/prism/compiler.rb#38
+ def visit_yield_node(node); end
+end
+
+# Represents the use of the `&&=` operator for assignment to a constant.
+#
+# Target &&= value
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#3972
+class Prism::ConstantAndWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#3986
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#3995
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4000
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4010
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4005
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4015
+ sig { params(params: T.untyped).returns(Prism::ConstantAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4000
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4029
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4039
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#3974
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3977
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4034
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#3980
+ 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#4063
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#3983
+ 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#4073
+ def type; end
+ end
+end
+
+# Represents assigning to a constant using an operator that isn't `=`.
+#
+# Target += value
+# ^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4082
+class Prism::ConstantOperatorWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+ #
+ # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4099
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ operator: Symbol,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4109
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4114
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4124
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4119
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4129
+ sig { params(params: T.untyped).returns(Prism::ConstantOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4114
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4144
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4149
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#4084
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4087
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#4096
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4090
+ 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#4174
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4093
+ 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#4184
+ def type; end
+ end
+end
+
+# Represents the use of the `||=` operator for assignment to a constant.
+#
+# Target ||= value
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4193
+class Prism::ConstantOrWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4207
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4216
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4221
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4231
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4226
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4236
+ sig { params(params: T.untyped).returns(Prism::ConstantOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4221
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4250
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4260
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#4195
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4198
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4255
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4201
+ 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#4284
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4204
+ 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#4294
+ 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#4303
+class Prism::ConstantPathAndWriteNode < ::Prism::Node
+ # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4314
+ sig do
+ params(
+ target: Prism::ConstantPathNode,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(target, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4322
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4327
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4337
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4332
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4342
+ sig { params(params: T.untyped).returns(Prism::ConstantPathAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4327
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4355
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4365
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4360
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4308
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader target: ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4305
+ 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#4389
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4311
+ 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#4399
+ def type; end
+ end
+end
+
+# Represents accessing a constant through a path of `::` operators.
+#
+# Foo::Bar
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4408
+class Prism::ConstantPathNode < ::Prism::Node
+ # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
+ #
+ # @return [ConstantPathNode] a new instance of ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4419
+ sig do
+ params(
+ parent: T.nilable(Prism::Node),
+ child: Prism::Node,
+ delimiter_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(parent, child, delimiter_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4427
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader child: Node
+ #
+ # source://prism//lib/prism/node.rb#4413
+ sig { returns(Prism::Node) }
+ def child; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4432
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4445
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4437
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4450
+ sig { params(params: T.untyped).returns(Prism::ConstantPathNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4432
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4463
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def delimiter: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4468
+ sig { returns(String) }
+ def delimiter; end
+
+ # attr_reader delimiter_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4416
+ sig { returns(Prism::Location) }
+ def delimiter_loc; end
+
+ # Returns the full name of this constant path. For example: "Foo::Bar"
+ #
+ # source://prism//lib/prism/node_ext.rb#129
+ def full_name; end
+
+ # Returns the list of parts for the full name of this constant path.
+ # For example: [:Foo, :Bar]
+ #
+ # source://prism//lib/prism/node_ext.rb#112
+ def full_name_parts; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4473
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader parent: Node?
+ #
+ # source://prism//lib/prism/node.rb#4410
+ 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#4501
+ 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#4511
+ 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#108
+class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
+
+# Represents assigning to a constant path using an operator that isn't `=`.
+#
+# Parent::Child += value
+# ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#4520
+class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
+ # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+ #
+ # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4534
+ sig do
+ params(
+ target: Prism::ConstantPathNode,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ operator: Symbol,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(target, operator_loc, value, operator, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4543
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4548
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4558
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4553
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4563
+ sig { params(params: T.untyped).returns(Prism::ConstantPathOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4548
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4577
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4582
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#4531
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4525
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader target: ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4522
+ 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#4607
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4528
+ 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#4617
+ 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#4626
+class Prism::ConstantPathOrWriteNode < ::Prism::Node
+ # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4637
+ sig do
+ params(
+ target: Prism::ConstantPathNode,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(target, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4645
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4650
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4660
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4655
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4665
+ sig { params(params: T.untyped).returns(Prism::ConstantPathOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4650
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4678
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4688
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4683
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4631
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader target: ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4628
+ 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#4712
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4634
+ 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#4722
+ 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#4731
+class Prism::ConstantPathTargetNode < ::Prism::Node
+ # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
+ #
+ # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
+ #
+ # source://prism//lib/prism/node.rb#4742
+ sig do
+ params(
+ parent: T.nilable(Prism::Node),
+ child: Prism::Node,
+ delimiter_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(parent, child, delimiter_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4750
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader child: Node
+ #
+ # source://prism//lib/prism/node.rb#4736
+ sig { returns(Prism::Node) }
+ def child; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4755
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4768
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4760
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathTargetNode
+ #
+ # source://prism//lib/prism/node.rb#4773
+ sig { params(params: T.untyped).returns(Prism::ConstantPathTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4755
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4786
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def delimiter: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4791
+ sig { returns(String) }
+ def delimiter; end
+
+ # attr_reader delimiter_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4739
+ sig { returns(Prism::Location) }
+ def delimiter_loc; end
+
+ # Returns the full name of this constant path. For example: "Foo::Bar"
+ #
+ # source://prism//lib/prism/node_ext.rb#142
+ def full_name; end
+
+ # Returns the list of parts for the full name of this constant path.
+ # For example: [:Foo, :Bar]
+ #
+ # source://prism//lib/prism/node_ext.rb#137
+ def full_name_parts; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4796
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader parent: Node?
+ #
+ # source://prism//lib/prism/node.rb#4733
+ 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#4824
+ 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#4834
+ 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#4849
+class Prism::ConstantPathWriteNode < ::Prism::Node
+ # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4860
+ sig do
+ params(
+ target: Prism::ConstantPathNode,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(target, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4868
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4873
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4883
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4878
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantPathWriteNode
+ #
+ # source://prism//lib/prism/node.rb#4888
+ sig { params(params: T.untyped).returns(Prism::ConstantPathWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4873
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4901
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#4911
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#4906
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#4854
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader target: ConstantPathNode
+ #
+ # source://prism//lib/prism/node.rb#4851
+ 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#4935
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#4857
+ 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#4945
+ def type; end
+ end
+end
+
+# Represents referencing a constant.
+#
+# Foo
+# ^^^
+#
+# source://prism//lib/prism/node.rb#4954
+class Prism::ConstantReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [ConstantReadNode] a new instance of ConstantReadNode
+ #
+ # source://prism//lib/prism/node.rb#4959
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#4965
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4970
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#4980
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#4975
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantReadNode
+ #
+ # source://prism//lib/prism/node.rb#4985
+ sig { params(params: T.untyped).returns(Prism::ConstantReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#4970
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#4996
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # Returns the full name of this constant. For example: "Foo"
+ #
+ # source://prism//lib/prism/node_ext.rb#96
+ def full_name; end
+
+ # Returns the list of parts for the full name of this constant.
+ # For example: [:Foo]
+ #
+ # source://prism//lib/prism/node_ext.rb#91
+ def full_name_parts; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5001
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#4956
+ 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#5021
+ 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#5031
+ 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#5040
+class Prism::ConstantTargetNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [ConstantTargetNode] a new instance of ConstantTargetNode
+ #
+ # source://prism//lib/prism/node.rb#5045
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5051
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5056
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5066
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5061
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantTargetNode
+ #
+ # source://prism//lib/prism/node.rb#5071
+ sig { params(params: T.untyped).returns(Prism::ConstantTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5056
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5082
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5087
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#5042
+ 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#5107
+ 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#5117
+ def type; end
+ end
+end
+
+# Represents writing to a constant.
+#
+# Foo = 1
+# ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5126
+class Prism::ConstantWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [ConstantWriteNode] a new instance of ConstantWriteNode
+ #
+ # source://prism//lib/prism/node.rb#5140
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ value: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5149
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5154
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5164
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5159
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ConstantWriteNode
+ #
+ # source://prism//lib/prism/node.rb#5169
+ sig { params(params: T.untyped).returns(Prism::ConstantWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5154
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5183
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5193
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#5128
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5131
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5188
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5137
+ 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#5217
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#5134
+ 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#5227
+ def type; end
+ end
+end
+
+class Prism::DATAComment < Prism::Comment; end
+
+# The DSL module provides a set of methods that can be used to create prism
+# nodes in a more concise manner. For example, instead of writing:
+#
+# source = Prism::Source.new("[1]")
+#
+# Prism::ArrayNode.new(
+# [
+# Prism::IntegerNode.new(
+# Prism::IntegerBaseFlags::DECIMAL,
+# Prism::Location.new(source, 1, 1),
+# )
+# ],
+# Prism::Location.new(source, 0, 1),
+# Prism::Location.new(source, 2, 1)
+# )
+#
+# you could instead write:
+#
+# source = Prism::Source.new("[1]")
+#
+# ArrayNode(
+# IntegerNode(Prism::IntegerBaseFlags::DECIMAL, Location(source, 1, 1))),
+# Location(source, 0, 1),
+# Location(source, 2, 1)
+# )
+#
+# This is mostly helpful in the context of writing tests, but can also be used
+# to generate trees programmatically.
+#
+# source://prism//lib/prism/dsl.rb#37
+module Prism::DSL
+ private
+
+ # Create a new AliasGlobalVariableNode node
+ #
+ # source://prism//lib/prism/dsl.rb#46
+ def AliasGlobalVariableNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new AliasMethodNode node
+ #
+ # source://prism//lib/prism/dsl.rb#51
+ def AliasMethodNode(new_name, old_name, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new AlternationPatternNode node
+ #
+ # source://prism//lib/prism/dsl.rb#56
+ def AlternationPatternNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new AndNode node
+ #
+ # source://prism//lib/prism/dsl.rb#61
+ def AndNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new ArgumentsNode node
+ #
+ # source://prism//lib/prism/dsl.rb#66
+ def ArgumentsNode(flags, arguments, location = T.unsafe(nil)); end
+
+ # Create a new ArrayNode node
+ #
+ # source://prism//lib/prism/dsl.rb#71
+ def ArrayNode(flags, elements, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new ArrayPatternNode node
+ #
+ # source://prism//lib/prism/dsl.rb#76
+ def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new AssocNode node
+ #
+ # source://prism//lib/prism/dsl.rb#81
+ def AssocNode(key, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new AssocSplatNode node
+ #
+ # source://prism//lib/prism/dsl.rb#86
+ def AssocSplatNode(value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new BackReferenceReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#91
+ def BackReferenceReadNode(name, location = T.unsafe(nil)); end
+
+ # Create a new BeginNode node
+ #
+ # source://prism//lib/prism/dsl.rb#96
+ def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new BlockArgumentNode node
+ #
+ # source://prism//lib/prism/dsl.rb#101
+ def BlockArgumentNode(expression, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new BlockLocalVariableNode node
+ #
+ # source://prism//lib/prism/dsl.rb#106
+ def BlockLocalVariableNode(name, location = T.unsafe(nil)); end
+
+ # Create a new BlockNode node
+ #
+ # source://prism//lib/prism/dsl.rb#111
+ def BlockNode(locals, locals_body_index, parameters, body, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new BlockParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#116
+ def BlockParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new BlockParametersNode node
+ #
+ # source://prism//lib/prism/dsl.rb#121
+ def BlockParametersNode(parameters, locals, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new BreakNode node
+ #
+ # source://prism//lib/prism/dsl.rb#126
+ def BreakNode(arguments, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new CallAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#131
+ def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new CallNode node
+ #
+ # source://prism//lib/prism/dsl.rb#136
+ def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location = T.unsafe(nil)); end
+
+ # Create a new CallOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#141
+ def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new CallOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#146
+ def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new CallTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#151
+ def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, location = T.unsafe(nil)); end
+
+ # Create a new CapturePatternNode node
+ #
+ # source://prism//lib/prism/dsl.rb#156
+ def CapturePatternNode(value, target, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new CaseMatchNode node
+ #
+ # source://prism//lib/prism/dsl.rb#161
+ def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new CaseNode node
+ #
+ # source://prism//lib/prism/dsl.rb#166
+ def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new ClassNode node
+ #
+ # source://prism//lib/prism/dsl.rb#171
+ def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#176
+ def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#181
+ def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#186
+ def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#191
+ def ClassVariableReadNode(name, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#196
+ def ClassVariableTargetNode(name, location = T.unsafe(nil)); end
+
+ # Create a new ClassVariableWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#201
+ def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new ConstantAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#206
+ def ConstantAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ConstantOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#211
+ def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+ # Create a new ConstantOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#216
+ def ConstantOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#221
+ def ConstantPathAndWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathNode node
+ #
+ # source://prism//lib/prism/dsl.rb#226
+ def ConstantPathNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#231
+ def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#236
+ def ConstantPathOrWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#241
+ def ConstantPathTargetNode(parent, child, delimiter_loc, location = T.unsafe(nil)); end
+
+ # Create a new ConstantPathWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#246
+ def ConstantPathWriteNode(target, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new ConstantReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#251
+ def ConstantReadNode(name, location = T.unsafe(nil)); end
+
+ # Create a new ConstantTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#256
+ def ConstantTargetNode(name, location = T.unsafe(nil)); end
+
+ # Create a new ConstantWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#261
+ def ConstantWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new DefNode node
+ #
+ # source://prism//lib/prism/dsl.rb#266
+ def DefNode(name, name_loc, receiver, parameters, body, locals, locals_body_index, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new DefinedNode node
+ #
+ # source://prism//lib/prism/dsl.rb#271
+ def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new ElseNode node
+ #
+ # source://prism//lib/prism/dsl.rb#276
+ def ElseNode(else_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new EmbeddedStatementsNode node
+ #
+ # source://prism//lib/prism/dsl.rb#281
+ def EmbeddedStatementsNode(opening_loc, statements, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new EmbeddedVariableNode node
+ #
+ # source://prism//lib/prism/dsl.rb#286
+ def EmbeddedVariableNode(operator_loc, variable, location = T.unsafe(nil)); end
+
+ # Create a new EnsureNode node
+ #
+ # source://prism//lib/prism/dsl.rb#291
+ def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new FalseNode node
+ #
+ # source://prism//lib/prism/dsl.rb#296
+ def FalseNode(location = T.unsafe(nil)); end
+
+ # Create a new FindPatternNode node
+ #
+ # source://prism//lib/prism/dsl.rb#301
+ def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new FlipFlopNode node
+ #
+ # source://prism//lib/prism/dsl.rb#306
+ def FlipFlopNode(flags, left, right, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new FloatNode node
+ #
+ # source://prism//lib/prism/dsl.rb#311
+ def FloatNode(location = T.unsafe(nil)); end
+
+ # Create a new ForNode node
+ #
+ # source://prism//lib/prism/dsl.rb#316
+ def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new ForwardingArgumentsNode node
+ #
+ # source://prism//lib/prism/dsl.rb#321
+ def ForwardingArgumentsNode(location = T.unsafe(nil)); end
+
+ # Create a new ForwardingParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#326
+ def ForwardingParameterNode(location = T.unsafe(nil)); end
+
+ # Create a new ForwardingSuperNode node
+ #
+ # source://prism//lib/prism/dsl.rb#331
+ def ForwardingSuperNode(block, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#336
+ def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#341
+ def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#346
+ def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#351
+ def GlobalVariableReadNode(name, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#356
+ def GlobalVariableTargetNode(name, location = T.unsafe(nil)); end
+
+ # Create a new GlobalVariableWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#361
+ def GlobalVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new HashNode node
+ #
+ # source://prism//lib/prism/dsl.rb#366
+ def HashNode(opening_loc, elements, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new HashPatternNode node
+ #
+ # source://prism//lib/prism/dsl.rb#371
+ def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new IfNode node
+ #
+ # source://prism//lib/prism/dsl.rb#376
+ def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new ImaginaryNode node
+ #
+ # source://prism//lib/prism/dsl.rb#381
+ def ImaginaryNode(numeric, location = T.unsafe(nil)); end
+
+ # Create a new ImplicitNode node
+ #
+ # source://prism//lib/prism/dsl.rb#386
+ def ImplicitNode(value, location = T.unsafe(nil)); end
+
+ # Create a new ImplicitRestNode node
+ #
+ # source://prism//lib/prism/dsl.rb#391
+ def ImplicitRestNode(location = T.unsafe(nil)); end
+
+ # Create a new InNode node
+ #
+ # source://prism//lib/prism/dsl.rb#396
+ def InNode(pattern, statements, in_loc, then_loc, location = T.unsafe(nil)); end
+
+ # Create a new IndexAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#401
+ def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new IndexOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#406
+ def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new IndexOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#411
+ def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new IndexTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#416
+ def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#421
+ def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#426
+ def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#431
+ def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#436
+ def InstanceVariableReadNode(name, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#441
+ def InstanceVariableTargetNode(name, location = T.unsafe(nil)); end
+
+ # Create a new InstanceVariableWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#446
+ def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new IntegerNode node
+ #
+ # source://prism//lib/prism/dsl.rb#451
+ def IntegerNode(flags, location = T.unsafe(nil)); end
+
+ # Create a new InterpolatedMatchLastLineNode node
+ #
+ # source://prism//lib/prism/dsl.rb#456
+ def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new InterpolatedRegularExpressionNode node
+ #
+ # source://prism//lib/prism/dsl.rb#461
+ def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new InterpolatedStringNode node
+ #
+ # source://prism//lib/prism/dsl.rb#466
+ def InterpolatedStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new InterpolatedSymbolNode node
+ #
+ # source://prism//lib/prism/dsl.rb#471
+ def InterpolatedSymbolNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new InterpolatedXStringNode node
+ #
+ # source://prism//lib/prism/dsl.rb#476
+ def InterpolatedXStringNode(opening_loc, parts, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new KeywordHashNode node
+ #
+ # source://prism//lib/prism/dsl.rb#481
+ def KeywordHashNode(flags, elements, location = T.unsafe(nil)); end
+
+ # Create a new KeywordRestParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#486
+ def KeywordRestParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new LambdaNode node
+ #
+ # source://prism//lib/prism/dsl.rb#491
+ def LambdaNode(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#496
+ def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#501
+ def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#506
+ def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#511
+ def LocalVariableReadNode(name, depth, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#516
+ def LocalVariableTargetNode(name, depth, location = T.unsafe(nil)); end
+
+ # Create a new LocalVariableWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#521
+ def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new Location object
+ #
+ # source://prism//lib/prism/dsl.rb#41
+ def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end
+
+ # Create a new MatchLastLineNode node
+ #
+ # source://prism//lib/prism/dsl.rb#526
+ def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+ # Create a new MatchPredicateNode node
+ #
+ # source://prism//lib/prism/dsl.rb#531
+ def MatchPredicateNode(value, pattern, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new MatchRequiredNode node
+ #
+ # source://prism//lib/prism/dsl.rb#536
+ def MatchRequiredNode(value, pattern, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new MatchWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#541
+ def MatchWriteNode(call, targets, location = T.unsafe(nil)); end
+
+ # Create a new MissingNode node
+ #
+ # source://prism//lib/prism/dsl.rb#546
+ def MissingNode(location = T.unsafe(nil)); end
+
+ # Create a new ModuleNode node
+ #
+ # source://prism//lib/prism/dsl.rb#551
+ def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location = T.unsafe(nil)); end
+
+ # Create a new MultiTargetNode node
+ #
+ # source://prism//lib/prism/dsl.rb#556
+ def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, location = T.unsafe(nil)); end
+
+ # Create a new MultiWriteNode node
+ #
+ # source://prism//lib/prism/dsl.rb#561
+ def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new NextNode node
+ #
+ # source://prism//lib/prism/dsl.rb#566
+ def NextNode(arguments, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new NilNode node
+ #
+ # source://prism//lib/prism/dsl.rb#571
+ def NilNode(location = T.unsafe(nil)); end
+
+ # Create a new NoKeywordsParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#576
+ def NoKeywordsParameterNode(operator_loc, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new NumberedParametersNode node
+ #
+ # source://prism//lib/prism/dsl.rb#581
+ def NumberedParametersNode(maximum, location = T.unsafe(nil)); end
+
+ # Create a new NumberedReferenceReadNode node
+ #
+ # source://prism//lib/prism/dsl.rb#586
+ def NumberedReferenceReadNode(number, location = T.unsafe(nil)); end
+
+ # Create a new OptionalKeywordParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#591
+ def OptionalKeywordParameterNode(name, name_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new OptionalParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#596
+ def OptionalParameterNode(name, name_loc, operator_loc, value, location = T.unsafe(nil)); end
+
+ # Create a new OrNode node
+ #
+ # source://prism//lib/prism/dsl.rb#601
+ def OrNode(left, right, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new ParametersNode node
+ #
+ # source://prism//lib/prism/dsl.rb#606
+ def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, location = T.unsafe(nil)); end
+
+ # Create a new ParenthesesNode node
+ #
+ # source://prism//lib/prism/dsl.rb#611
+ def ParenthesesNode(body, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new PinnedExpressionNode node
+ #
+ # source://prism//lib/prism/dsl.rb#616
+ def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, location = T.unsafe(nil)); end
+
+ # Create a new PinnedVariableNode node
+ #
+ # source://prism//lib/prism/dsl.rb#621
+ def PinnedVariableNode(variable, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new PostExecutionNode node
+ #
+ # source://prism//lib/prism/dsl.rb#626
+ def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new PreExecutionNode node
+ #
+ # source://prism//lib/prism/dsl.rb#631
+ def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, location = T.unsafe(nil)); end
+
+ # Create a new ProgramNode node
+ #
+ # source://prism//lib/prism/dsl.rb#636
+ def ProgramNode(locals, statements, location = T.unsafe(nil)); end
+
+ # Create a new RangeNode node
+ #
+ # source://prism//lib/prism/dsl.rb#641
+ def RangeNode(flags, left, right, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new RationalNode node
+ #
+ # source://prism//lib/prism/dsl.rb#646
+ def RationalNode(numeric, location = T.unsafe(nil)); end
+
+ # Create a new RedoNode node
+ #
+ # source://prism//lib/prism/dsl.rb#651
+ def RedoNode(location = T.unsafe(nil)); end
+
+ # Create a new RegularExpressionNode node
+ #
+ # source://prism//lib/prism/dsl.rb#656
+ def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+ # Create a new RequiredKeywordParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#661
+ def RequiredKeywordParameterNode(name, name_loc, location = T.unsafe(nil)); end
+
+ # Create a new RequiredParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#666
+ def RequiredParameterNode(name, location = T.unsafe(nil)); end
+
+ # Create a new RescueModifierNode node
+ #
+ # source://prism//lib/prism/dsl.rb#671
+ def RescueModifierNode(expression, keyword_loc, rescue_expression, location = T.unsafe(nil)); end
+
+ # Create a new RescueNode node
+ #
+ # source://prism//lib/prism/dsl.rb#676
+ def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location = T.unsafe(nil)); end
+
+ # Create a new RestParameterNode node
+ #
+ # source://prism//lib/prism/dsl.rb#681
+ def RestParameterNode(name, name_loc, operator_loc, location = T.unsafe(nil)); end
+
+ # Create a new RetryNode node
+ #
+ # source://prism//lib/prism/dsl.rb#686
+ def RetryNode(location = T.unsafe(nil)); end
+
+ # Create a new ReturnNode node
+ #
+ # source://prism//lib/prism/dsl.rb#691
+ def ReturnNode(keyword_loc, arguments, location = T.unsafe(nil)); end
+
+ # Create a new SelfNode node
+ #
+ # source://prism//lib/prism/dsl.rb#696
+ def SelfNode(location = T.unsafe(nil)); end
+
+ # Create a new SingletonClassNode node
+ #
+ # source://prism//lib/prism/dsl.rb#701
+ def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new SourceEncodingNode node
+ #
+ # source://prism//lib/prism/dsl.rb#706
+ def SourceEncodingNode(location = T.unsafe(nil)); end
+
+ # Create a new SourceFileNode node
+ #
+ # source://prism//lib/prism/dsl.rb#711
+ def SourceFileNode(filepath, location = T.unsafe(nil)); end
+
+ # Create a new SourceLineNode node
+ #
+ # source://prism//lib/prism/dsl.rb#716
+ def SourceLineNode(location = T.unsafe(nil)); end
+
+ # Create a new SplatNode node
+ #
+ # source://prism//lib/prism/dsl.rb#721
+ def SplatNode(operator_loc, expression, location = T.unsafe(nil)); end
+
+ # Create a new StatementsNode node
+ #
+ # source://prism//lib/prism/dsl.rb#726
+ def StatementsNode(body, location = T.unsafe(nil)); end
+
+ # Create a new StringNode node
+ #
+ # source://prism//lib/prism/dsl.rb#731
+ def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+ # Create a new SuperNode node
+ #
+ # source://prism//lib/prism/dsl.rb#736
+ def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, location = T.unsafe(nil)); end
+
+ # Create a new SymbolNode node
+ #
+ # source://prism//lib/prism/dsl.rb#741
+ def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+ # Create a new TrueNode node
+ #
+ # source://prism//lib/prism/dsl.rb#746
+ def TrueNode(location = T.unsafe(nil)); end
+
+ # Create a new UndefNode node
+ #
+ # source://prism//lib/prism/dsl.rb#751
+ def UndefNode(names, keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new UnlessNode node
+ #
+ # source://prism//lib/prism/dsl.rb#756
+ def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location = T.unsafe(nil)); end
+
+ # Create a new UntilNode node
+ #
+ # source://prism//lib/prism/dsl.rb#761
+ def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, location = T.unsafe(nil)); end
+
+ # Create a new WhenNode node
+ #
+ # source://prism//lib/prism/dsl.rb#766
+ def WhenNode(keyword_loc, conditions, statements, location = T.unsafe(nil)); end
+
+ # Create a new WhileNode node
+ #
+ # source://prism//lib/prism/dsl.rb#771
+ def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, location = T.unsafe(nil)); end
+
+ # Create a new XStringNode node
+ #
+ # source://prism//lib/prism/dsl.rb#776
+ def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, location = T.unsafe(nil)); end
+
+ # Create a new YieldNode node
+ #
+ # source://prism//lib/prism/dsl.rb#781
+ def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, location = T.unsafe(nil)); end
+end
+
+# This module is used for testing and debugging and is not meant to be used by
+# consumers of this library.
+#
+# source://prism//lib/prism/debug.rb#6
+module Prism::Debug
+ class << self
+ # :call-seq:
+ # Debug::cruby_locals(source) -> Array
+ #
+ # For the given source, compiles with CRuby and returns a list of all of the
+ # sets of local variables that were encountered.
+ #
+ # source://prism//lib/prism/debug.rb#54
+ def cruby_locals(source); end
+
+ def inspect_node(_arg0); end
+ def memsize(_arg0); end
+ def named_captures(_arg0); end
+
+ # :call-seq:
+ # Debug::newlines(source) -> Array
+ #
+ # For the given source string, return the byte offsets of every newline in
+ # the source.
+ #
+ # source://prism//lib/prism/debug.rb#196
+ def newlines(source); end
+
+ # :call-seq:
+ # Debug::prism_locals(source) -> Array
+ #
+ # For the given source, parses with prism and returns a list of all of the
+ # sets of local variables that were encountered.
+ #
+ # source://prism//lib/prism/debug.rb#98
+ def prism_locals(source); end
+
+ def profile_file(_arg0); end
+ end
+end
+
+# Used to hold the place of a local that will be in the local table but
+# cannot be accessed directly from the source code. For example, the
+# iteration variable in a for loop or the positional parameter on a method
+# definition that is destructured.
+#
+# source://prism//lib/prism/debug.rb#90
+Prism::Debug::AnonymousLocal = T.let(T.unsafe(nil), Object)
+
+# A wrapper around a RubyVM::InstructionSequence that provides a more
+# convenient interface for accessing parts of the iseq.
+#
+# source://prism//lib/prism/debug.rb#9
+class Prism::Debug::ISeq
+ # @return [ISeq] a new instance of ISeq
+ #
+ # source://prism//lib/prism/debug.rb#12
+ def initialize(parts); end
+
+ # source://prism//lib/prism/debug.rb#28
+ def each_child; end
+
+ # source://prism//lib/prism/debug.rb#24
+ def instructions; end
+
+ # source://prism//lib/prism/debug.rb#20
+ def local_table; end
+
+ # source://prism//lib/prism/debug.rb#10
+ def parts; end
+
+ # source://prism//lib/prism/debug.rb#16
+ def type; end
+end
+
+# Represents a method definition.
+#
+# def method
+# end
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5237
+class Prism::DefNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], locals_body_index: Integer, def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
+ #
+ # @return [DefNode] a new instance of DefNode
+ #
+ # source://prism//lib/prism/node.rb#5278
+ 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],
+ locals_body_index: Integer,
+ 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(name, name_loc, receiver, parameters, body, locals, locals_body_index, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5296
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#5251
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5301
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5315
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5306
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> DefNode
+ #
+ # source://prism//lib/prism/node.rb#5320
+ sig { params(params: T.untyped).returns(Prism::DefNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5301
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5343
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def def_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5348
+ sig { returns(String) }
+ def def_keyword; end
+
+ # attr_reader def_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5260
+ sig { returns(Prism::Location) }
+ def def_keyword_loc; end
+
+ # def end_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5373
+ sig { returns(T.nilable(String)) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5275
+ sig { returns(T.nilable(Prism::Location)) }
+ def end_keyword_loc; end
+
+ # def equal: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5368
+ sig { returns(T.nilable(String)) }
+ def equal; end
+
+ # attr_reader equal_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5272
+ sig { returns(T.nilable(Prism::Location)) }
+ def equal_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5378
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#5254
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # attr_reader locals_body_index: Integer
+ #
+ # source://prism//lib/prism/node.rb#5257
+ sig { returns(Integer) }
+ def locals_body_index; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5358
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5266
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#5239
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5242
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5353
+ sig { returns(T.nilable(String)) }
+ def operator; end
+
+ # attr_reader operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5263
+ sig { returns(T.nilable(Prism::Location)) }
+ def operator_loc; end
+
+ # attr_reader parameters: ParametersNode?
+ #
+ # source://prism//lib/prism/node.rb#5248
+ sig { returns(T.nilable(Prism::ParametersNode)) }
+ def parameters; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#5245
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5363
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5269
+ 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#5425
+ 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#5435
+ def type; end
+ end
+end
+
+# Represents the use of the `defined?` keyword.
+#
+# defined?(a)
+# ^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5444
+class Prism::DefinedNode < ::Prism::Node
+ # def initialize: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [DefinedNode] a new instance of DefinedNode
+ #
+ # source://prism//lib/prism/node.rb#5458
+ 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
+ ).void
+ end
+ def initialize(lparen_loc, value, rparen_loc, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5467
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5472
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5482
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5477
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> DefinedNode
+ #
+ # source://prism//lib/prism/node.rb#5487
+ sig { params(params: T.untyped).returns(Prism::DefinedNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5472
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5501
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5521
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5516
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5455
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5506
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5446
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5511
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5452
+ 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#5545
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#5449
+ 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#5555
+ def type; end
+ end
+end
+
+# DesugarCompiler is a compiler that desugars Ruby code into a more primitive
+# form. This is useful for consumers that want to deal with fewer node types.
+#
+# source://prism//lib/prism/desugar_compiler.rb#6
+class Prism::DesugarCompiler < ::Prism::MutationCompiler
+ # @@foo &&= bar
+ #
+ # becomes
+ #
+ # @@foo && @@foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#12
+ def visit_class_variable_and_write_node(node); end
+
+ # @@foo += bar
+ #
+ # becomes
+ #
+ # @@foo = @@foo + bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#30
+ def visit_class_variable_operator_write_node(node); end
+
+ # @@foo ||= bar
+ #
+ # becomes
+ #
+ # defined?(@@foo) ? @@foo : @@foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#21
+ def visit_class_variable_or_write_node(node); end
+
+ # Foo &&= bar
+ #
+ # becomes
+ #
+ # Foo && Foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#39
+ def visit_constant_and_write_node(node); end
+
+ # Foo += bar
+ #
+ # becomes
+ #
+ # Foo = Foo + bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#57
+ def visit_constant_operator_write_node(node); end
+
+ # Foo ||= bar
+ #
+ # becomes
+ #
+ # defined?(Foo) ? Foo : Foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#48
+ def visit_constant_or_write_node(node); end
+
+ # $foo &&= bar
+ #
+ # becomes
+ #
+ # $foo && $foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#66
+ def visit_global_variable_and_write_node(node); end
+
+ # $foo += bar
+ #
+ # becomes
+ #
+ # $foo = $foo + bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#84
+ def visit_global_variable_operator_write_node(node); end
+
+ # $foo ||= bar
+ #
+ # becomes
+ #
+ # defined?($foo) ? $foo : $foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#75
+ def visit_global_variable_or_write_node(node); end
+
+ # becomes
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#93
+ def visit_instance_variable_and_write_node(node); end
+
+ # becomes
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#111
+ def visit_instance_variable_operator_write_node(node); end
+
+ # becomes
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#102
+ def visit_instance_variable_or_write_node(node); end
+
+ # foo &&= bar
+ #
+ # becomes
+ #
+ # foo && foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#120
+ def visit_local_variable_and_write_node(node); end
+
+ # foo += bar
+ #
+ # becomes
+ #
+ # foo = foo + bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#138
+ def visit_local_variable_operator_write_node(node); end
+
+ # foo ||= bar
+ #
+ # becomes
+ #
+ # foo || foo = bar
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#129
+ def visit_local_variable_or_write_node(node); end
+
+ private
+
+ # Desugar `x &&= y` to `x && x = y`
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#145
+ def desugar_and_write_node(node, read_class, write_class, *arguments); end
+
+ # Desugar `x += y` to `x = x + y`
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#155
+ def desugar_operator_write_node(node, read_class, write_class, *arguments); end
+
+ # Desugar `x ||= y` to `defined?(x) ? x : x = y`
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#187
+ def desugar_or_write_defined_node(node, read_class, write_class, *arguments); end
+
+ # Desugar `x ||= y` to `x || x = y`
+ #
+ # source://prism//lib/prism/desugar_compiler.rb#177
+ def desugar_or_write_node(node, read_class, write_class, *arguments); end
+end
+
+# The dispatcher class fires events for nodes that are found while walking an
+# AST to all registered listeners. It's useful for performing different types
+# of analysis on the AST while only having to walk the tree once.
+#
+# To use the dispatcher, you would first instantiate it and register listeners
+# for the events you're interested in:
+#
+# class OctalListener
+# def on_integer_node_enter(node)
+# if node.octal? && !node.slice.start_with?("0o")
+# warn("Octal integers should be written with the 0o prefix")
+# end
+# end
+# end
+#
+# dispatcher = Dispatcher.new
+# dispatcher.register(listener, :on_integer_node_enter)
+#
+# Then, you can walk any number of trees and dispatch events to the listeners:
+#
+# result = Prism.parse("001 + 002 + 003")
+# dispatcher.dispatch(result.value)
+#
+# Optionally, you can also use `#dispatch_once` to dispatch enter and leave
+# events for a single node without recursing further down the tree. This can
+# be useful in circumstances where you want to reuse the listeners you already
+# have registers but want to stop walking the tree at a certain point.
+#
+# integer = result.value.statements.body.first.receiver.receiver
+# dispatcher.dispatch_once(integer)
+#
+# source://prism//lib/prism/dispatcher.rb#40
+class Prism::Dispatcher < ::Prism::Visitor
+ # Initialize a new dispatcher.
+ #
+ # @return [Dispatcher] a new instance of Dispatcher
+ #
+ # source://prism//lib/prism/dispatcher.rb#45
+ def initialize; end
+
+ # Walks `root` dispatching events to all registered listeners.
+ #
+ # def dispatch: (Node) -> void
+ #
+ # source://prism//lib/prism/visitor.rb#16
+ def dispatch(node); end
+
+ # Dispatches a single event for `node` to all registered listeners.
+ #
+ # def dispatch_once: (Node) -> void
+ #
+ # source://prism//lib/prism/dispatcher.rb#64
+ def dispatch_once(node); end
+
+ # attr_reader listeners: Hash[Symbol, Array[Listener]]
+ #
+ # source://prism//lib/prism/dispatcher.rb#42
+ def listeners; end
+
+ # Register a listener for one or more events.
+ #
+ # def register: (Listener, *Symbol) -> void
+ #
+ # source://prism//lib/prism/dispatcher.rb#52
+ def register(listener, *events); end
+
+ # Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#70
+ def visit_alias_global_variable_node(node); end
+
+ # Dispatch enter and leave events for AliasMethodNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#78
+ def visit_alias_method_node(node); end
+
+ # Dispatch enter and leave events for AlternationPatternNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#86
+ def visit_alternation_pattern_node(node); end
+
+ # Dispatch enter and leave events for AndNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#94
+ def visit_and_node(node); end
+
+ # Dispatch enter and leave events for ArgumentsNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#102
+ def visit_arguments_node(node); end
+
+ # Dispatch enter and leave events for ArrayNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#110
+ def visit_array_node(node); end
+
+ # Dispatch enter and leave events for ArrayPatternNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#118
+ def visit_array_pattern_node(node); end
+
+ # Dispatch enter and leave events for AssocNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#126
+ def visit_assoc_node(node); end
+
+ # Dispatch enter and leave events for AssocSplatNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#134
+ def visit_assoc_splat_node(node); end
+
+ # Dispatch enter and leave events for BackReferenceReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#142
+ def visit_back_reference_read_node(node); end
+
+ # Dispatch enter and leave events for BeginNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#150
+ def visit_begin_node(node); end
+
+ # Dispatch enter and leave events for BlockArgumentNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#158
+ def visit_block_argument_node(node); end
+
+ # Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#166
+ def visit_block_local_variable_node(node); end
+
+ # Dispatch enter and leave events for BlockNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#174
+ def visit_block_node(node); end
+
+ # Dispatch enter and leave events for BlockParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#182
+ def visit_block_parameter_node(node); end
+
+ # Dispatch enter and leave events for BlockParametersNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#190
+ def visit_block_parameters_node(node); end
+
+ # Dispatch enter and leave events for BreakNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#198
+ def visit_break_node(node); end
+
+ # Dispatch enter and leave events for CallAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#206
+ def visit_call_and_write_node(node); end
+
+ # Dispatch enter and leave events for CallNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#214
+ def visit_call_node(node); end
+
+ # Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#222
+ def visit_call_operator_write_node(node); end
+
+ # Dispatch enter and leave events for CallOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#230
+ def visit_call_or_write_node(node); end
+
+ # Dispatch enter and leave events for CallTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#238
+ def visit_call_target_node(node); end
+
+ # Dispatch enter and leave events for CapturePatternNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#246
+ def visit_capture_pattern_node(node); end
+
+ # Dispatch enter and leave events for CaseMatchNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#254
+ def visit_case_match_node(node); end
+
+ # Dispatch enter and leave events for CaseNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#262
+ def visit_case_node(node); end
+
+ # Dispatch enter and leave events for ClassNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#270
+ def visit_class_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#278
+ def visit_class_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#286
+ def visit_class_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#294
+ def visit_class_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#302
+ def visit_class_variable_read_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#310
+ def visit_class_variable_target_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#318
+ def visit_class_variable_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#326
+ def visit_constant_and_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#334
+ def visit_constant_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#342
+ def visit_constant_or_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#350
+ def visit_constant_path_and_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#358
+ def visit_constant_path_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#366
+ def visit_constant_path_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#374
+ def visit_constant_path_or_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#382
+ def visit_constant_path_target_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#390
+ def visit_constant_path_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#398
+ def visit_constant_read_node(node); end
+
+ # Dispatch enter and leave events for ConstantTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#406
+ def visit_constant_target_node(node); end
+
+ # Dispatch enter and leave events for ConstantWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#414
+ def visit_constant_write_node(node); end
+
+ # Dispatch enter and leave events for DefNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#422
+ def visit_def_node(node); end
+
+ # Dispatch enter and leave events for DefinedNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#430
+ def visit_defined_node(node); end
+
+ # Dispatch enter and leave events for ElseNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#438
+ def visit_else_node(node); end
+
+ # Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#446
+ def visit_embedded_statements_node(node); end
+
+ # Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#454
+ def visit_embedded_variable_node(node); end
+
+ # Dispatch enter and leave events for EnsureNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#462
+ def visit_ensure_node(node); end
+
+ # Dispatch enter and leave events for FalseNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#470
+ def visit_false_node(node); end
+
+ # Dispatch enter and leave events for FindPatternNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#478
+ def visit_find_pattern_node(node); end
+
+ # Dispatch enter and leave events for FlipFlopNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#486
+ def visit_flip_flop_node(node); end
+
+ # Dispatch enter and leave events for FloatNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#494
+ def visit_float_node(node); end
+
+ # Dispatch enter and leave events for ForNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#502
+ def visit_for_node(node); end
+
+ # Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#510
+ def visit_forwarding_arguments_node(node); end
+
+ # Dispatch enter and leave events for ForwardingParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#518
+ def visit_forwarding_parameter_node(node); end
+
+ # Dispatch enter and leave events for ForwardingSuperNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#526
+ def visit_forwarding_super_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#534
+ def visit_global_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#542
+ def visit_global_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#550
+ def visit_global_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#558
+ def visit_global_variable_read_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#566
+ def visit_global_variable_target_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#574
+ def visit_global_variable_write_node(node); end
+
+ # Dispatch enter and leave events for HashNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#582
+ def visit_hash_node(node); end
+
+ # Dispatch enter and leave events for HashPatternNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#590
+ def visit_hash_pattern_node(node); end
+
+ # Dispatch enter and leave events for IfNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#598
+ def visit_if_node(node); end
+
+ # Dispatch enter and leave events for ImaginaryNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#606
+ def visit_imaginary_node(node); end
+
+ # Dispatch enter and leave events for ImplicitNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#614
+ def visit_implicit_node(node); end
+
+ # Dispatch enter and leave events for ImplicitRestNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#622
+ def visit_implicit_rest_node(node); end
+
+ # Dispatch enter and leave events for InNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#630
+ def visit_in_node(node); end
+
+ # Dispatch enter and leave events for IndexAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#638
+ def visit_index_and_write_node(node); end
+
+ # Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#646
+ def visit_index_operator_write_node(node); end
+
+ # Dispatch enter and leave events for IndexOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#654
+ def visit_index_or_write_node(node); end
+
+ # Dispatch enter and leave events for IndexTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#662
+ def visit_index_target_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#670
+ def visit_instance_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#678
+ def visit_instance_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#686
+ def visit_instance_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#694
+ def visit_instance_variable_read_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#702
+ def visit_instance_variable_target_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#710
+ def visit_instance_variable_write_node(node); end
+
+ # Dispatch enter and leave events for IntegerNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#718
+ def visit_integer_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#726
+ def visit_interpolated_match_last_line_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#734
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedStringNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#742
+ def visit_interpolated_string_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#750
+ def visit_interpolated_symbol_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#758
+ def visit_interpolated_x_string_node(node); end
+
+ # Dispatch enter and leave events for KeywordHashNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#766
+ def visit_keyword_hash_node(node); end
+
+ # Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#774
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Dispatch enter and leave events for LambdaNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#782
+ def visit_lambda_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#790
+ def visit_local_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#798
+ def visit_local_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#806
+ def visit_local_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#814
+ def visit_local_variable_read_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#822
+ def visit_local_variable_target_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#830
+ def visit_local_variable_write_node(node); end
+
+ # Dispatch enter and leave events for MatchLastLineNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#838
+ def visit_match_last_line_node(node); end
+
+ # Dispatch enter and leave events for MatchPredicateNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#846
+ def visit_match_predicate_node(node); end
+
+ # Dispatch enter and leave events for MatchRequiredNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#854
+ def visit_match_required_node(node); end
+
+ # Dispatch enter and leave events for MatchWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#862
+ def visit_match_write_node(node); end
+
+ # Dispatch enter and leave events for MissingNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#870
+ def visit_missing_node(node); end
+
+ # Dispatch enter and leave events for ModuleNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#878
+ def visit_module_node(node); end
+
+ # Dispatch enter and leave events for MultiTargetNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#886
+ def visit_multi_target_node(node); end
+
+ # Dispatch enter and leave events for MultiWriteNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#894
+ def visit_multi_write_node(node); end
+
+ # Dispatch enter and leave events for NextNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#902
+ def visit_next_node(node); end
+
+ # Dispatch enter and leave events for NilNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#910
+ def visit_nil_node(node); end
+
+ # Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#918
+ def visit_no_keywords_parameter_node(node); end
+
+ # Dispatch enter and leave events for NumberedParametersNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#926
+ def visit_numbered_parameters_node(node); end
+
+ # Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#934
+ def visit_numbered_reference_read_node(node); end
+
+ # Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#942
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Dispatch enter and leave events for OptionalParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#950
+ def visit_optional_parameter_node(node); end
+
+ # Dispatch enter and leave events for OrNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#958
+ def visit_or_node(node); end
+
+ # Dispatch enter and leave events for ParametersNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#966
+ def visit_parameters_node(node); end
+
+ # Dispatch enter and leave events for ParenthesesNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#974
+ def visit_parentheses_node(node); end
+
+ # Dispatch enter and leave events for PinnedExpressionNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#982
+ def visit_pinned_expression_node(node); end
+
+ # Dispatch enter and leave events for PinnedVariableNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#990
+ def visit_pinned_variable_node(node); end
+
+ # Dispatch enter and leave events for PostExecutionNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#998
+ def visit_post_execution_node(node); end
+
+ # Dispatch enter and leave events for PreExecutionNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1006
+ def visit_pre_execution_node(node); end
+
+ # Dispatch enter and leave events for ProgramNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1014
+ def visit_program_node(node); end
+
+ # Dispatch enter and leave events for RangeNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1022
+ def visit_range_node(node); end
+
+ # Dispatch enter and leave events for RationalNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1030
+ def visit_rational_node(node); end
+
+ # Dispatch enter and leave events for RedoNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1038
+ def visit_redo_node(node); end
+
+ # Dispatch enter and leave events for RegularExpressionNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1046
+ def visit_regular_expression_node(node); end
+
+ # Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1054
+ def visit_required_keyword_parameter_node(node); end
+
+ # Dispatch enter and leave events for RequiredParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1062
+ def visit_required_parameter_node(node); end
+
+ # Dispatch enter and leave events for RescueModifierNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1070
+ def visit_rescue_modifier_node(node); end
+
+ # Dispatch enter and leave events for RescueNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1078
+ def visit_rescue_node(node); end
+
+ # Dispatch enter and leave events for RestParameterNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1086
+ def visit_rest_parameter_node(node); end
+
+ # Dispatch enter and leave events for RetryNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1094
+ def visit_retry_node(node); end
+
+ # Dispatch enter and leave events for ReturnNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1102
+ def visit_return_node(node); end
+
+ # Dispatch enter and leave events for SelfNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1110
+ def visit_self_node(node); end
+
+ # Dispatch enter and leave events for SingletonClassNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1118
+ def visit_singleton_class_node(node); end
+
+ # Dispatch enter and leave events for SourceEncodingNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1126
+ def visit_source_encoding_node(node); end
+
+ # Dispatch enter and leave events for SourceFileNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1134
+ def visit_source_file_node(node); end
+
+ # Dispatch enter and leave events for SourceLineNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1142
+ def visit_source_line_node(node); end
+
+ # Dispatch enter and leave events for SplatNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1150
+ def visit_splat_node(node); end
+
+ # Dispatch enter and leave events for StatementsNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1158
+ def visit_statements_node(node); end
+
+ # Dispatch enter and leave events for StringNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1166
+ def visit_string_node(node); end
+
+ # Dispatch enter and leave events for SuperNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1174
+ def visit_super_node(node); end
+
+ # Dispatch enter and leave events for SymbolNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1182
+ def visit_symbol_node(node); end
+
+ # Dispatch enter and leave events for TrueNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1190
+ def visit_true_node(node); end
+
+ # Dispatch enter and leave events for UndefNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1198
+ def visit_undef_node(node); end
+
+ # Dispatch enter and leave events for UnlessNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1206
+ def visit_unless_node(node); end
+
+ # Dispatch enter and leave events for UntilNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1214
+ def visit_until_node(node); end
+
+ # Dispatch enter and leave events for WhenNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1222
+ def visit_when_node(node); end
+
+ # Dispatch enter and leave events for WhileNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1230
+ def visit_while_node(node); end
+
+ # Dispatch enter and leave events for XStringNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1238
+ def visit_x_string_node(node); end
+
+ # Dispatch enter and leave events for YieldNode nodes and continue
+ # walking the tree.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1246
+ def visit_yield_node(node); end
+end
+
+# source://prism//lib/prism/dispatcher.rb#1252
+class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
+ # @return [DispatchOnce] a new instance of DispatchOnce
+ #
+ # source://prism//lib/prism/dispatcher.rb#1255
+ def initialize(listeners); end
+
+ # Returns the value of attribute listeners.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1253
+ def listeners; end
+
+ # Dispatch enter and leave events for AliasGlobalVariableNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1260
+ def visit_alias_global_variable_node(node); end
+
+ # Dispatch enter and leave events for AliasMethodNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1266
+ def visit_alias_method_node(node); end
+
+ # Dispatch enter and leave events for AlternationPatternNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1272
+ def visit_alternation_pattern_node(node); end
+
+ # Dispatch enter and leave events for AndNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1278
+ def visit_and_node(node); end
+
+ # Dispatch enter and leave events for ArgumentsNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1284
+ def visit_arguments_node(node); end
+
+ # Dispatch enter and leave events for ArrayNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1290
+ def visit_array_node(node); end
+
+ # Dispatch enter and leave events for ArrayPatternNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1296
+ def visit_array_pattern_node(node); end
+
+ # Dispatch enter and leave events for AssocNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1302
+ def visit_assoc_node(node); end
+
+ # Dispatch enter and leave events for AssocSplatNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1308
+ def visit_assoc_splat_node(node); end
+
+ # Dispatch enter and leave events for BackReferenceReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1314
+ def visit_back_reference_read_node(node); end
+
+ # Dispatch enter and leave events for BeginNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1320
+ def visit_begin_node(node); end
+
+ # Dispatch enter and leave events for BlockArgumentNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1326
+ def visit_block_argument_node(node); end
+
+ # Dispatch enter and leave events for BlockLocalVariableNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1332
+ def visit_block_local_variable_node(node); end
+
+ # Dispatch enter and leave events for BlockNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1338
+ def visit_block_node(node); end
+
+ # Dispatch enter and leave events for BlockParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1344
+ def visit_block_parameter_node(node); end
+
+ # Dispatch enter and leave events for BlockParametersNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1350
+ def visit_block_parameters_node(node); end
+
+ # Dispatch enter and leave events for BreakNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1356
+ def visit_break_node(node); end
+
+ # Dispatch enter and leave events for CallAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1362
+ def visit_call_and_write_node(node); end
+
+ # Dispatch enter and leave events for CallNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1368
+ def visit_call_node(node); end
+
+ # Dispatch enter and leave events for CallOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1374
+ def visit_call_operator_write_node(node); end
+
+ # Dispatch enter and leave events for CallOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1380
+ def visit_call_or_write_node(node); end
+
+ # Dispatch enter and leave events for CallTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1386
+ def visit_call_target_node(node); end
+
+ # Dispatch enter and leave events for CapturePatternNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1392
+ def visit_capture_pattern_node(node); end
+
+ # Dispatch enter and leave events for CaseMatchNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1398
+ def visit_case_match_node(node); end
+
+ # Dispatch enter and leave events for CaseNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1404
+ def visit_case_node(node); end
+
+ # Dispatch enter and leave events for ClassNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1410
+ def visit_class_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1416
+ def visit_class_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1422
+ def visit_class_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1428
+ def visit_class_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1434
+ def visit_class_variable_read_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1440
+ def visit_class_variable_target_node(node); end
+
+ # Dispatch enter and leave events for ClassVariableWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1446
+ def visit_class_variable_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1452
+ def visit_constant_and_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1458
+ def visit_constant_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1464
+ def visit_constant_or_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1470
+ def visit_constant_path_and_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1476
+ def visit_constant_path_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1482
+ def visit_constant_path_operator_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1488
+ def visit_constant_path_or_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1494
+ def visit_constant_path_target_node(node); end
+
+ # Dispatch enter and leave events for ConstantPathWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1500
+ def visit_constant_path_write_node(node); end
+
+ # Dispatch enter and leave events for ConstantReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1506
+ def visit_constant_read_node(node); end
+
+ # Dispatch enter and leave events for ConstantTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1512
+ def visit_constant_target_node(node); end
+
+ # Dispatch enter and leave events for ConstantWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1518
+ def visit_constant_write_node(node); end
+
+ # Dispatch enter and leave events for DefNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1524
+ def visit_def_node(node); end
+
+ # Dispatch enter and leave events for DefinedNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1530
+ def visit_defined_node(node); end
+
+ # Dispatch enter and leave events for ElseNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1536
+ def visit_else_node(node); end
+
+ # Dispatch enter and leave events for EmbeddedStatementsNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1542
+ def visit_embedded_statements_node(node); end
+
+ # Dispatch enter and leave events for EmbeddedVariableNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1548
+ def visit_embedded_variable_node(node); end
+
+ # Dispatch enter and leave events for EnsureNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1554
+ def visit_ensure_node(node); end
+
+ # Dispatch enter and leave events for FalseNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1560
+ def visit_false_node(node); end
+
+ # Dispatch enter and leave events for FindPatternNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1566
+ def visit_find_pattern_node(node); end
+
+ # Dispatch enter and leave events for FlipFlopNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1572
+ def visit_flip_flop_node(node); end
+
+ # Dispatch enter and leave events for FloatNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1578
+ def visit_float_node(node); end
+
+ # Dispatch enter and leave events for ForNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1584
+ def visit_for_node(node); end
+
+ # Dispatch enter and leave events for ForwardingArgumentsNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1590
+ def visit_forwarding_arguments_node(node); end
+
+ # Dispatch enter and leave events for ForwardingParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1596
+ def visit_forwarding_parameter_node(node); end
+
+ # Dispatch enter and leave events for ForwardingSuperNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1602
+ def visit_forwarding_super_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1608
+ def visit_global_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1614
+ def visit_global_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1620
+ def visit_global_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1626
+ def visit_global_variable_read_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1632
+ def visit_global_variable_target_node(node); end
+
+ # Dispatch enter and leave events for GlobalVariableWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1638
+ def visit_global_variable_write_node(node); end
+
+ # Dispatch enter and leave events for HashNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1644
+ def visit_hash_node(node); end
+
+ # Dispatch enter and leave events for HashPatternNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1650
+ def visit_hash_pattern_node(node); end
+
+ # Dispatch enter and leave events for IfNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1656
+ def visit_if_node(node); end
+
+ # Dispatch enter and leave events for ImaginaryNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1662
+ def visit_imaginary_node(node); end
+
+ # Dispatch enter and leave events for ImplicitNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1668
+ def visit_implicit_node(node); end
+
+ # Dispatch enter and leave events for ImplicitRestNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1674
+ def visit_implicit_rest_node(node); end
+
+ # Dispatch enter and leave events for InNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1680
+ def visit_in_node(node); end
+
+ # Dispatch enter and leave events for IndexAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1686
+ def visit_index_and_write_node(node); end
+
+ # Dispatch enter and leave events for IndexOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1692
+ def visit_index_operator_write_node(node); end
+
+ # Dispatch enter and leave events for IndexOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1698
+ def visit_index_or_write_node(node); end
+
+ # Dispatch enter and leave events for IndexTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1704
+ def visit_index_target_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1710
+ def visit_instance_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1716
+ def visit_instance_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1722
+ def visit_instance_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1728
+ def visit_instance_variable_read_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1734
+ def visit_instance_variable_target_node(node); end
+
+ # Dispatch enter and leave events for InstanceVariableWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1740
+ def visit_instance_variable_write_node(node); end
+
+ # Dispatch enter and leave events for IntegerNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1746
+ def visit_integer_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1752
+ def visit_interpolated_match_last_line_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1758
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedStringNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1764
+ def visit_interpolated_string_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedSymbolNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1770
+ def visit_interpolated_symbol_node(node); end
+
+ # Dispatch enter and leave events for InterpolatedXStringNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1776
+ def visit_interpolated_x_string_node(node); end
+
+ # Dispatch enter and leave events for KeywordHashNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1782
+ def visit_keyword_hash_node(node); end
+
+ # Dispatch enter and leave events for KeywordRestParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1788
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Dispatch enter and leave events for LambdaNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1794
+ def visit_lambda_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1800
+ def visit_local_variable_and_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1806
+ def visit_local_variable_operator_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1812
+ def visit_local_variable_or_write_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1818
+ def visit_local_variable_read_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1824
+ def visit_local_variable_target_node(node); end
+
+ # Dispatch enter and leave events for LocalVariableWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1830
+ def visit_local_variable_write_node(node); end
+
+ # Dispatch enter and leave events for MatchLastLineNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1836
+ def visit_match_last_line_node(node); end
+
+ # Dispatch enter and leave events for MatchPredicateNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1842
+ def visit_match_predicate_node(node); end
+
+ # Dispatch enter and leave events for MatchRequiredNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1848
+ def visit_match_required_node(node); end
+
+ # Dispatch enter and leave events for MatchWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1854
+ def visit_match_write_node(node); end
+
+ # Dispatch enter and leave events for MissingNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1860
+ def visit_missing_node(node); end
+
+ # Dispatch enter and leave events for ModuleNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1866
+ def visit_module_node(node); end
+
+ # Dispatch enter and leave events for MultiTargetNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1872
+ def visit_multi_target_node(node); end
+
+ # Dispatch enter and leave events for MultiWriteNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1878
+ def visit_multi_write_node(node); end
+
+ # Dispatch enter and leave events for NextNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1884
+ def visit_next_node(node); end
+
+ # Dispatch enter and leave events for NilNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1890
+ def visit_nil_node(node); end
+
+ # Dispatch enter and leave events for NoKeywordsParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1896
+ def visit_no_keywords_parameter_node(node); end
+
+ # Dispatch enter and leave events for NumberedParametersNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1902
+ def visit_numbered_parameters_node(node); end
+
+ # Dispatch enter and leave events for NumberedReferenceReadNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1908
+ def visit_numbered_reference_read_node(node); end
+
+ # Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1914
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Dispatch enter and leave events for OptionalParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1920
+ def visit_optional_parameter_node(node); end
+
+ # Dispatch enter and leave events for OrNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1926
+ def visit_or_node(node); end
+
+ # Dispatch enter and leave events for ParametersNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1932
+ def visit_parameters_node(node); end
+
+ # Dispatch enter and leave events for ParenthesesNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1938
+ def visit_parentheses_node(node); end
+
+ # Dispatch enter and leave events for PinnedExpressionNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1944
+ def visit_pinned_expression_node(node); end
+
+ # Dispatch enter and leave events for PinnedVariableNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1950
+ def visit_pinned_variable_node(node); end
+
+ # Dispatch enter and leave events for PostExecutionNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1956
+ def visit_post_execution_node(node); end
+
+ # Dispatch enter and leave events for PreExecutionNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1962
+ def visit_pre_execution_node(node); end
+
+ # Dispatch enter and leave events for ProgramNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1968
+ def visit_program_node(node); end
+
+ # Dispatch enter and leave events for RangeNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1974
+ def visit_range_node(node); end
+
+ # Dispatch enter and leave events for RationalNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1980
+ def visit_rational_node(node); end
+
+ # Dispatch enter and leave events for RedoNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1986
+ def visit_redo_node(node); end
+
+ # Dispatch enter and leave events for RegularExpressionNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1992
+ def visit_regular_expression_node(node); end
+
+ # Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#1998
+ def visit_required_keyword_parameter_node(node); end
+
+ # Dispatch enter and leave events for RequiredParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2004
+ def visit_required_parameter_node(node); end
+
+ # Dispatch enter and leave events for RescueModifierNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2010
+ def visit_rescue_modifier_node(node); end
+
+ # Dispatch enter and leave events for RescueNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2016
+ def visit_rescue_node(node); end
+
+ # Dispatch enter and leave events for RestParameterNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2022
+ def visit_rest_parameter_node(node); end
+
+ # Dispatch enter and leave events for RetryNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2028
+ def visit_retry_node(node); end
+
+ # Dispatch enter and leave events for ReturnNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2034
+ def visit_return_node(node); end
+
+ # Dispatch enter and leave events for SelfNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2040
+ def visit_self_node(node); end
+
+ # Dispatch enter and leave events for SingletonClassNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2046
+ def visit_singleton_class_node(node); end
+
+ # Dispatch enter and leave events for SourceEncodingNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2052
+ def visit_source_encoding_node(node); end
+
+ # Dispatch enter and leave events for SourceFileNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2058
+ def visit_source_file_node(node); end
+
+ # Dispatch enter and leave events for SourceLineNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2064
+ def visit_source_line_node(node); end
+
+ # Dispatch enter and leave events for SplatNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2070
+ def visit_splat_node(node); end
+
+ # Dispatch enter and leave events for StatementsNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2076
+ def visit_statements_node(node); end
+
+ # Dispatch enter and leave events for StringNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2082
+ def visit_string_node(node); end
+
+ # Dispatch enter and leave events for SuperNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2088
+ def visit_super_node(node); end
+
+ # Dispatch enter and leave events for SymbolNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2094
+ def visit_symbol_node(node); end
+
+ # Dispatch enter and leave events for TrueNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2100
+ def visit_true_node(node); end
+
+ # Dispatch enter and leave events for UndefNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2106
+ def visit_undef_node(node); end
+
+ # Dispatch enter and leave events for UnlessNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2112
+ def visit_unless_node(node); end
+
+ # Dispatch enter and leave events for UntilNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2118
+ def visit_until_node(node); end
+
+ # Dispatch enter and leave events for WhenNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2124
+ def visit_when_node(node); end
+
+ # Dispatch enter and leave events for WhileNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2130
+ def visit_while_node(node); end
+
+ # Dispatch enter and leave events for XStringNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2136
+ def visit_x_string_node(node); end
+
+ # Dispatch enter and leave events for YieldNode nodes.
+ #
+ # source://prism//lib/prism/dispatcher.rb#2142
+ def visit_yield_node(node); end
+end
+
+# This visitor provides the ability to call Node#to_dot, which converts a
+# subtree into a graphviz dot graph.
+#
+# source://prism//lib/prism/dot_visitor.rb#13
+class Prism::DotVisitor < ::Prism::Visitor
+ # Initialize a new dot visitor.
+ #
+ # @return [DotVisitor] a new instance of DotVisitor
+ #
+ # source://prism//lib/prism/dot_visitor.rb#105
+ def initialize; end
+
+ # The digraph that is being built.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#102
+ def digraph; end
+
+ # Convert this visitor into a graphviz dot graph string.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#110
+ def to_dot; end
+
+ # Visit a AliasGlobalVariableNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#115
+ def visit_alias_global_variable_node(node); end
+
+ # Visit a AliasMethodNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#140
+ def visit_alias_method_node(node); end
+
+ # Visit a AlternationPatternNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#165
+ def visit_alternation_pattern_node(node); end
+
+ # Visit a AndNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#190
+ def visit_and_node(node); end
+
+ # Visit a ArgumentsNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#215
+ def visit_arguments_node(node); end
+
+ # Visit a ArrayNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#245
+ def visit_array_node(node); end
+
+ # Visit a ArrayPatternNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#285
+ def visit_array_pattern_node(node); end
+
+ # Visit a AssocNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#347
+ def visit_assoc_node(node); end
+
+ # Visit a AssocSplatNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#376
+ def visit_assoc_splat_node(node); end
+
+ # Visit a BackReferenceReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#399
+ def visit_back_reference_read_node(node); end
+
+ # Visit a BeginNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#416
+ def visit_begin_node(node); end
+
+ # Visit a BlockArgumentNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#464
+ def visit_block_argument_node(node); end
+
+ # Visit a BlockLocalVariableNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#487
+ def visit_block_local_variable_node(node); end
+
+ # Visit a BlockNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#504
+ def visit_block_node(node); end
+
+ # Visit a BlockParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#542
+ def visit_block_parameter_node(node); end
+
+ # Visit a BlockParametersNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#567
+ def visit_block_parameters_node(node); end
+
+ # Visit a BreakNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#610
+ def visit_break_node(node); end
+
+ # Visit a CallAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#633
+ def visit_call_and_write_node(node); end
+
+ # Visit a CallNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#679
+ def visit_call_node(node); end
+
+ # Visit a CallOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#737
+ def visit_call_operator_write_node(node); end
+
+ # Visit a CallOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#786
+ def visit_call_or_write_node(node); end
+
+ # Visit a CallTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#832
+ def visit_call_target_node(node); end
+
+ # Visit a CapturePatternNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#862
+ def visit_capture_pattern_node(node); end
+
+ # Visit a CaseMatchNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#887
+ def visit_case_match_node(node); end
+
+ # Visit a CaseNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#932
+ def visit_case_node(node); end
+
+ # Visit a ClassNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#977
+ def visit_class_node(node); end
+
+ # Visit a ClassVariableAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1024
+ def visit_class_variable_and_write_node(node); end
+
+ # Visit a ClassVariableOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1051
+ def visit_class_variable_operator_write_node(node); end
+
+ # Visit a ClassVariableOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1081
+ def visit_class_variable_or_write_node(node); end
+
+ # Visit a ClassVariableReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1108
+ def visit_class_variable_read_node(node); end
+
+ # Visit a ClassVariableTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1125
+ def visit_class_variable_target_node(node); end
+
+ # Visit a ClassVariableWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1142
+ 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#1307
+ def visit_constant_path_operator_write_node(node); end
+
+ # Visit a ConstantPathOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1335
+ def visit_constant_path_or_write_node(node); end
+
+ # Visit a ConstantPathTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1360
+ def visit_constant_path_target_node(node); end
+
+ # Visit a ConstantPathWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1387
+ def visit_constant_path_write_node(node); end
+
+ # Visit a ConstantReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1412
+ def visit_constant_read_node(node); end
+
+ # Visit a ConstantTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1429
+ def visit_constant_target_node(node); end
+
+ # Visit a ConstantWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1446
+ def visit_constant_write_node(node); end
+
+ # Visit a DefNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1473
+ def visit_def_node(node); end
+
+ # Visit a DefinedNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1545
+ def visit_defined_node(node); end
+
+ # Visit a ElseNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1576
+ def visit_else_node(node); end
+
+ # Visit a EmbeddedStatementsNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1604
+ def visit_embedded_statements_node(node); end
+
+ # Visit a EmbeddedVariableNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1630
+ def visit_embedded_variable_node(node); end
+
+ # Visit a EnsureNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1651
+ def visit_ensure_node(node); end
+
+ # Visit a FalseNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1677
+ def visit_false_node(node); end
+
+ # Visit a FindPatternNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1691
+ def visit_find_pattern_node(node); end
+
+ # Visit a FlipFlopNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1742
+ def visit_flip_flop_node(node); end
+
+ # Visit a FloatNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1774
+ def visit_float_node(node); end
+
+ # Visit a ForNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1788
+ def visit_for_node(node); end
+
+ # Visit a ForwardingArgumentsNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1830
+ def visit_forwarding_arguments_node(node); end
+
+ # Visit a ForwardingParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1844
+ def visit_forwarding_parameter_node(node); end
+
+ # Visit a ForwardingSuperNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1858
+ def visit_forwarding_super_node(node); end
+
+ # Visit a GlobalVariableAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1878
+ def visit_global_variable_and_write_node(node); end
+
+ # Visit a GlobalVariableOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1905
+ def visit_global_variable_operator_write_node(node); end
+
+ # Visit a GlobalVariableOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1935
+ def visit_global_variable_or_write_node(node); end
+
+ # Visit a GlobalVariableReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1962
+ def visit_global_variable_read_node(node); end
+
+ # Visit a GlobalVariableTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1979
+ def visit_global_variable_target_node(node); end
+
+ # Visit a GlobalVariableWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#1996
+ def visit_global_variable_write_node(node); end
+
+ # Visit a HashNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2023
+ def visit_hash_node(node); end
+
+ # Visit a HashPatternNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2056
+ def visit_hash_pattern_node(node); end
+
+ # Visit a IfNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2105
+ def visit_if_node(node); end
+
+ # Visit a ImaginaryNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2150
+ def visit_imaginary_node(node); end
+
+ # Visit a ImplicitNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2168
+ def visit_implicit_node(node); end
+
+ # Visit a ImplicitRestNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2186
+ def visit_implicit_rest_node(node); end
+
+ # Visit a InNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2200
+ def visit_in_node(node); end
+
+ # Visit a IndexAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2232
+ def visit_index_and_write_node(node); end
+
+ # Visit a IndexOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2285
+ def visit_index_operator_write_node(node); end
+
+ # Visit a IndexOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2341
+ def visit_index_or_write_node(node); end
+
+ # Visit a IndexTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2394
+ def visit_index_target_node(node); end
+
+ # Visit a InstanceVariableAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2433
+ def visit_instance_variable_and_write_node(node); end
+
+ # Visit a InstanceVariableOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2460
+ def visit_instance_variable_operator_write_node(node); end
+
+ # Visit a InstanceVariableOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2490
+ def visit_instance_variable_or_write_node(node); end
+
+ # Visit a InstanceVariableReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2517
+ def visit_instance_variable_read_node(node); end
+
+ # Visit a InstanceVariableTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2534
+ def visit_instance_variable_target_node(node); end
+
+ # Visit a InstanceVariableWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2551
+ def visit_instance_variable_write_node(node); end
+
+ # Visit a IntegerNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2578
+ def visit_integer_node(node); end
+
+ # Visit a InterpolatedMatchLastLineNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2595
+ def visit_interpolated_match_last_line_node(node); end
+
+ # Visit a InterpolatedRegularExpressionNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2631
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Visit a InterpolatedStringNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2667
+ def visit_interpolated_string_node(node); end
+
+ # Visit a InterpolatedSymbolNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2704
+ def visit_interpolated_symbol_node(node); end
+
+ # Visit a InterpolatedXStringNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2741
+ def visit_interpolated_x_string_node(node); end
+
+ # Visit a KeywordHashNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2774
+ def visit_keyword_hash_node(node); end
+
+ # Visit a KeywordRestParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2804
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Visit a LambdaNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2829
+ def visit_lambda_node(node); end
+
+ # Visit a LocalVariableAndWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2870
+ def visit_local_variable_and_write_node(node); end
+
+ # Visit a LocalVariableOperatorWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2900
+ def visit_local_variable_operator_write_node(node); end
+
+ # Visit a LocalVariableOrWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2933
+ def visit_local_variable_or_write_node(node); end
+
+ # Visit a LocalVariableReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2963
+ def visit_local_variable_read_node(node); end
+
+ # Visit a LocalVariableTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#2983
+ def visit_local_variable_target_node(node); end
+
+ # Visit a LocalVariableWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3003
+ def visit_local_variable_write_node(node); end
+
+ # Visit a MatchLastLineNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3033
+ def visit_match_last_line_node(node); end
+
+ # Visit a MatchPredicateNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3062
+ def visit_match_predicate_node(node); end
+
+ # Visit a MatchRequiredNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3087
+ def visit_match_required_node(node); end
+
+ # Visit a MatchWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3112
+ def visit_match_write_node(node); end
+
+ # Visit a MissingNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3143
+ def visit_missing_node(node); end
+
+ # Visit a ModuleNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3157
+ def visit_module_node(node); end
+
+ # Visit a MultiTargetNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3193
+ def visit_multi_target_node(node); end
+
+ # Visit a MultiWriteNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3249
+ def visit_multi_write_node(node); end
+
+ # Visit a NextNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3312
+ def visit_next_node(node); end
+
+ # Visit a NilNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3335
+ def visit_nil_node(node); end
+
+ # Visit a NoKeywordsParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3349
+ def visit_no_keywords_parameter_node(node); end
+
+ # Visit a NumberedParametersNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3369
+ def visit_numbered_parameters_node(node); end
+
+ # Visit a NumberedReferenceReadNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3386
+ def visit_numbered_reference_read_node(node); end
+
+ # Visit a OptionalKeywordParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3403
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Visit a OptionalParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3427
+ def visit_optional_parameter_node(node); end
+
+ # Visit a OrNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3454
+ def visit_or_node(node); end
+
+ # Visit a ParametersNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3479
+ def visit_parameters_node(node); end
+
+ # Visit a ParenthesesNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3563
+ def visit_parentheses_node(node); end
+
+ # Visit a PinnedExpressionNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3589
+ def visit_pinned_expression_node(node); end
+
+ # Visit a PinnedVariableNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3616
+ def visit_pinned_variable_node(node); end
+
+ # Visit a PostExecutionNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3637
+ def visit_post_execution_node(node); end
+
+ # Visit a PreExecutionNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3666
+ def visit_pre_execution_node(node); end
+
+ # Visit a ProgramNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3695
+ def visit_program_node(node); end
+
+ # Visit a RangeNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3716
+ def visit_range_node(node); end
+
+ # Visit a RationalNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3748
+ def visit_rational_node(node); end
+
+ # Visit a RedoNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3766
+ def visit_redo_node(node); end
+
+ # Visit a RegularExpressionNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3780
+ def visit_regular_expression_node(node); end
+
+ # Visit a RequiredKeywordParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3809
+ def visit_required_keyword_parameter_node(node); end
+
+ # Visit a RequiredParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3829
+ def visit_required_parameter_node(node); end
+
+ # Visit a RescueModifierNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3846
+ def visit_rescue_modifier_node(node); end
+
+ # Visit a RescueNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3871
+ def visit_rescue_node(node); end
+
+ # Visit a RestParameterNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3924
+ def visit_rest_parameter_node(node); end
+
+ # Visit a RetryNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3949
+ def visit_retry_node(node); end
+
+ # Visit a ReturnNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3963
+ def visit_return_node(node); end
+
+ # Visit a SelfNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#3986
+ def visit_self_node(node); end
+
+ # Visit a SingletonClassNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4000
+ def visit_singleton_class_node(node); end
+
+ # Visit a SourceEncodingNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4036
+ def visit_source_encoding_node(node); end
+
+ # Visit a SourceFileNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4050
+ def visit_source_file_node(node); end
+
+ # Visit a SourceLineNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4067
+ def visit_source_line_node(node); end
+
+ # Visit a SplatNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4081
+ def visit_splat_node(node); end
+
+ # Visit a StatementsNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4104
+ def visit_statements_node(node); end
+
+ # Visit a StringNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4131
+ def visit_string_node(node); end
+
+ # Visit a SuperNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4164
+ def visit_super_node(node); end
+
+ # Visit a SymbolNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4203
+ def visit_symbol_node(node); end
+
+ # Visit a TrueNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4238
+ def visit_true_node(node); end
+
+ # Visit a UndefNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4252
+ def visit_undef_node(node); end
+
+ # Visit a UnlessNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4282
+ def visit_unless_node(node); end
+
+ # Visit a UntilNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4325
+ def visit_until_node(node); end
+
+ # Visit a WhenNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4360
+ def visit_when_node(node); end
+
+ # Visit a WhileNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4396
+ def visit_while_node(node); end
+
+ # Visit a XStringNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4431
+ def visit_x_string_node(node); end
+
+ # Visit a YieldNode node.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4460
+ 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#4506
+ 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#4514
+ 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#4522
+ 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#4532
+ 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#4541
+ def integer_base_flags_inspect(node); end
+
+ # Inspect a node that has keyword_hash_node_flags flags to display the flags as a
+ # comma-separated list.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4552
+ 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#4500
+ 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#4560
+ def loop_flags_inspect(node); end
+
+ # Generate a unique node ID for a node throughout the digraph.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4495
+ def node_id(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#4568
+ 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#4576
+ def regular_expression_flags_inspect(node); end
+
+ # Inspect a node that has string_flags flags to display the flags as a
+ # comma-separated list.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#4594
+ 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#4604
+ def symbol_flags_inspect(node); end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#58
+class Prism::DotVisitor::Digraph
+ # @return [Digraph] a new instance of Digraph
+ #
+ # source://prism//lib/prism/dot_visitor.rb#61
+ def initialize; end
+
+ # source://prism//lib/prism/dot_visitor.rb#75
+ def edge(value); end
+
+ # Returns the value of attribute edges.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#59
+ def edges; end
+
+ # source://prism//lib/prism/dot_visitor.rb#67
+ def node(value); end
+
+ # Returns the value of attribute nodes.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#59
+ def nodes; end
+
+ # source://prism//lib/prism/dot_visitor.rb#79
+ def to_dot; end
+
+ # source://prism//lib/prism/dot_visitor.rb#71
+ def waypoint(value); end
+
+ # Returns the value of attribute waypoints.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#59
+ def waypoints; end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#14
+class Prism::DotVisitor::Field
+ # @return [Field] a new instance of Field
+ #
+ # source://prism//lib/prism/dot_visitor.rb#17
+ def initialize(name, value, port); end
+
+ # Returns the value of attribute name.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#15
+ def name; end
+
+ # Returns the value of attribute port.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#15
+ def port; end
+
+ # source://prism//lib/prism/dot_visitor.rb#23
+ def to_dot; end
+
+ # Returns the value of attribute value.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#15
+ def value; end
+end
+
+# source://prism//lib/prism/dot_visitor.rb#32
+class Prism::DotVisitor::Table
+ # @return [Table] a new instance of Table
+ #
+ # source://prism//lib/prism/dot_visitor.rb#35
+ def initialize(name); end
+
+ # source://prism//lib/prism/dot_visitor.rb#40
+ def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
+
+ # Returns the value of attribute fields.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#33
+ def fields; end
+
+ # Returns the value of attribute name.
+ #
+ # source://prism//lib/prism/dot_visitor.rb#33
+ def name; end
+
+ # source://prism//lib/prism/dot_visitor.rb#44
+ def to_dot; end
+end
+
+# Represents an `else` clause in a `case`, `if`, or `unless` statement.
+#
+# if a then b else c end
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#5564
+class Prism::ElseNode < ::Prism::Node
+ # def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void
+ #
+ # @return [ElseNode] a new instance of ElseNode
+ #
+ # source://prism//lib/prism/node.rb#5575
+ sig do
+ params(
+ else_keyword_loc: Prism::Location,
+ statements: T.nilable(Prism::StatementsNode),
+ end_keyword_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(else_keyword_loc, statements, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5583
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5588
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5600
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5593
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ElseNode
+ #
+ # source://prism//lib/prism/node.rb#5605
+ sig { params(params: T.untyped).returns(Prism::ElseNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5588
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5618
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def else_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5623
+ sig { returns(String) }
+ def else_keyword; end
+
+ # attr_reader else_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5566
+ sig { returns(Prism::Location) }
+ def else_keyword_loc; end
+
+ # def end_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#5628
+ sig { returns(T.nilable(String)) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#5572
+ sig { returns(T.nilable(Prism::Location)) }
+ def end_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5633
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#5569
+ 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#5660
+ 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#5670
+ def type; end
+ end
+end
+
+# EmbDocComment objects correspond to comments that are surrounded by =begin
+# and =end.
+#
+# source://prism//lib/prism/parse_result.rb#260
+class Prism::EmbDocComment < ::Prism::Comment
+ # Returns a string representation of this comment.
+ #
+ # source://prism//lib/prism/parse_result.rb#267
+ def inspect; end
+
+ # This can only be true for inline comments.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/parse_result.rb#262
+ def trailing?; end
+end
+
+# Represents an interpolated set of statements.
+#
+# "foo #{bar}"
+# ^^^^^^
+#
+# source://prism//lib/prism/node.rb#5679
+class Prism::EmbeddedStatementsNode < ::Prism::Node
+ # def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void
+ #
+ # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode
+ #
+ # source://prism//lib/prism/node.rb#5690
+ sig do
+ params(
+ opening_loc: Prism::Location,
+ statements: T.nilable(Prism::StatementsNode),
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(opening_loc, statements, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5698
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5703
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5743
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5687
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5715
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5708
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> EmbeddedStatementsNode
+ #
+ # source://prism//lib/prism/node.rb#5720
+ sig { params(params: T.untyped).returns(Prism::EmbeddedStatementsNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5703
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5733
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5748
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5738
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5681
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#5684
+ 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#5775
+ 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#5785
+ def type; end
+ end
+end
+
+# Represents an interpolated variable.
+#
+# "foo #@bar"
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#5794
+class Prism::EmbeddedVariableNode < ::Prism::Node
+ # def initialize: (operator_loc: Location, variable: Node, location: Location) -> void
+ #
+ # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
+ #
+ # source://prism//lib/prism/node.rb#5802
+ sig { params(operator_loc: Prism::Location, variable: Prism::Node, location: Prism::Location).void }
+ def initialize(operator_loc, variable, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5809
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5814
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5824
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5819
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> EmbeddedVariableNode
+ #
+ # source://prism//lib/prism/node.rb#5829
+ sig { params(params: T.untyped).returns(Prism::EmbeddedVariableNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5814
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5841
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5851
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5846
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5796
+ 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#5873
+ def type; end
+
+ # attr_reader variable: Node
+ #
+ # source://prism//lib/prism/node.rb#5799
+ 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#5883
+ def type; end
+ end
+end
+
+# Flags for nodes that have unescaped content.
+#
+# source://prism//lib/prism/node.rb#17301
+module Prism::EncodingFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#17306
+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#17303
+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#5896
+class Prism::EnsureNode < ::Prism::Node
+ # def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void
+ #
+ # @return [EnsureNode] a new instance of EnsureNode
+ #
+ # source://prism//lib/prism/node.rb#5907
+ sig do
+ params(
+ ensure_keyword_loc: Prism::Location,
+ statements: T.nilable(Prism::StatementsNode),
+ end_keyword_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(ensure_keyword_loc, statements, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#5915
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5920
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#5932
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#5925
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> EnsureNode
+ #
+ # source://prism//lib/prism/node.rb#5937
+ sig { params(params: T.untyped).returns(Prism::EnsureNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#5920
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#5950
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5960
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5904
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def ensure_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#5955
+ sig { returns(String) }
+ def ensure_keyword; end
+
+ # attr_reader ensure_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#5898
+ sig { returns(Prism::Location) }
+ def ensure_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#5965
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#5901
+ 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#5992
+ 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 literal `false` keyword.
+#
+# false
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#6011
+class Prism::FalseNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [FalseNode] a new instance of FalseNode
+ #
+ # source://prism//lib/prism/node.rb#6013
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6018
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6023
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6033
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6028
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> FalseNode
+ #
+ # source://prism//lib/prism/node.rb#6038
+ sig { params(params: T.untyped).returns(Prism::FalseNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6023
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6048
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6053
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6072
+ 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#6082
+ 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#6097
+class Prism::FindPatternNode < ::Prism::Node
+ # def initialize: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+ #
+ # @return [FindPatternNode] a new instance of FindPatternNode
+ #
+ # source://prism//lib/prism/node.rb#6117
+ 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
+ ).void
+ end
+ def initialize(constant, left, requireds, right, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6128
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6133
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#6179
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#6114
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6148
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6138
+ def compact_child_nodes; end
+
+ # attr_reader constant: Node?
+ #
+ # source://prism//lib/prism/node.rb#6099
+ sig { returns(T.nilable(Prism::Node)) }
+ def constant; end
+
+ # def copy: (**params) -> FindPatternNode
+ #
+ # source://prism//lib/prism/node.rb#6153
+ sig { params(params: T.untyped).returns(Prism::FindPatternNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6133
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6169
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6184
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node
+ #
+ # source://prism//lib/prism/node.rb#6102
+ sig { returns(Prism::Node) }
+ def left; end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#6174
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#6111
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader requireds: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6105
+ sig { returns(T::Array[Prism::Node]) }
+ def requireds; end
+
+ # attr_reader right: Node
+ #
+ # source://prism//lib/prism/node.rb#6108
+ 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#6216
+ 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#6226
+ 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#6235
+class Prism::FlipFlopNode < ::Prism::Node
+ # def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [FlipFlopNode] a new instance of FlipFlopNode
+ #
+ # source://prism//lib/prism/node.rb#6249
+ sig do
+ params(
+ flags: Integer,
+ left: T.nilable(Prism::Node),
+ right: T.nilable(Prism::Node),
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, left, right, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6258
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6263
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6276
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6268
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> FlipFlopNode
+ #
+ # source://prism//lib/prism/node.rb#6281
+ sig { params(params: T.untyped).returns(Prism::FlipFlopNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6263
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6295
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def exclude_end?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#6300
+ sig { returns(T::Boolean) }
+ def exclude_end?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6310
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node?
+ #
+ # source://prism//lib/prism/node.rb#6240
+ sig { returns(T.nilable(Prism::Node)) }
+ def left; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#6305
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6246
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader right: Node?
+ #
+ # source://prism//lib/prism/node.rb#6243
+ 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#6344
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#6237
+ 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#6354
+ def type; end
+ end
+end
+
+# Represents a floating point number literal.
+#
+# 1.0
+# ^^^
+#
+# source://prism//lib/prism/node.rb#6363
+class Prism::FloatNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [FloatNode] a new instance of FloatNode
+ #
+ # source://prism//lib/prism/node.rb#6365
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6370
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6375
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6385
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6380
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> FloatNode
+ #
+ # source://prism//lib/prism/node.rb#6390
+ sig { params(params: T.untyped).returns(Prism::FloatNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6375
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6400
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6405
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6424
+ def type; end
+
+ # Returns the value of the node as a Ruby Float.
+ #
+ # source://prism//lib/prism/node_ext.rb#62
+ def value; end
+
+ class << self
+ # Similar to #type, this method returns a symbol that you can use for
+ # splitting on the type of the node without having to do a long === chain.
+ # Note that like #type, it will still be slower than using == for a single
+ # class, but should be faster in a case statement or an array comparison.
+ #
+ # def self.type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6434
+ def type; end
+ end
+end
+
+# Represents the use of the `for` keyword.
+#
+# for i in a end
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#6443
+class Prism::ForNode < ::Prism::Node
+ # def initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void
+ #
+ # @return [ForNode] a new instance of ForNode
+ #
+ # source://prism//lib/prism/node.rb#6466
+ 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
+ ).void
+ end
+ def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6478
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6483
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # attr_reader collection: Node
+ #
+ # source://prism//lib/prism/node.rb#6448
+ sig { returns(Prism::Node) }
+ def collection; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6497
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6488
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ForNode
+ #
+ # source://prism//lib/prism/node.rb#6502
+ sig { params(params: T.untyped).returns(Prism::ForNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6483
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6519
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def do_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#6534
+ sig { returns(T.nilable(String)) }
+ def do_keyword; end
+
+ # attr_reader do_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#6460
+ sig { returns(T.nilable(Prism::Location)) }
+ def do_keyword_loc; end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#6539
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6463
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def for_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#6524
+ sig { returns(String) }
+ def for_keyword; end
+
+ # attr_reader for_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6454
+ sig { returns(Prism::Location) }
+ def for_keyword_loc; end
+
+ # def in_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#6529
+ sig { returns(String) }
+ def in_keyword; end
+
+ # attr_reader in_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6457
+ sig { returns(Prism::Location) }
+ def in_keyword_loc; end
+
+ # attr_reader index: Node
+ #
+ # source://prism//lib/prism/node.rb#6445
+ sig { returns(Prism::Node) }
+ def index; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6544
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#6451
+ 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#6577
+ 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#6587
+ 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#6598
+class Prism::ForwardingArgumentsNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
+ #
+ # source://prism//lib/prism/node.rb#6600
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6605
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6610
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6620
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6615
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ForwardingArgumentsNode
+ #
+ # source://prism//lib/prism/node.rb#6625
+ sig { params(params: T.untyped).returns(Prism::ForwardingArgumentsNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6610
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6635
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6640
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6659
+ 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#6669
+ 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#6679
+class Prism::ForwardingParameterNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
+ #
+ # source://prism//lib/prism/node.rb#6681
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6686
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6691
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6701
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6696
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ForwardingParameterNode
+ #
+ # source://prism//lib/prism/node.rb#6706
+ sig { params(params: T.untyped).returns(Prism::ForwardingParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6691
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6716
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6721
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6740
+ 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#6750
+ def type; end
+ end
+end
+
+# Represents the use of the `super` keyword without parentheses or arguments.
+#
+# super
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#6759
+class Prism::ForwardingSuperNode < ::Prism::Node
+ # def initialize: (block: BlockNode?, location: Location) -> void
+ #
+ # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
+ #
+ # source://prism//lib/prism/node.rb#6764
+ sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).void }
+ def initialize(block, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6770
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader block: BlockNode?
+ #
+ # source://prism//lib/prism/node.rb#6761
+ sig { returns(T.nilable(Prism::BlockNode)) }
+ def block; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6775
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6787
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6780
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ForwardingSuperNode
+ #
+ # source://prism//lib/prism/node.rb#6792
+ sig { params(params: T.untyped).returns(Prism::ForwardingSuperNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6775
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6803
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6808
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#6833
+ 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#6843
+ 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#6852
+class Prism::GlobalVariableAndWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#6866
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6875
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6880
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#6890
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6885
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#6895
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6880
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#6909
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#6919
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#6854
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6857
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#6914
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6860
+ 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#6943
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#6863
+ 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#6953
+ 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#6962
+class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+ #
+ # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#6979
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ operator: Symbol,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#6989
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6994
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7004
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#6999
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#7009
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#6994
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7024
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7029
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#6964
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6967
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#6976
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#6970
+ 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#7054
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#6973
+ 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#7064
+ 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#7073
+class Prism::GlobalVariableOrWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#7087
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7096
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7101
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7111
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7106
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#7116
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7101
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7130
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7140
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#7075
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7078
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#7135
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7081
+ 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#7164
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#7084
+ 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#7174
+ def type; end
+ end
+end
+
+# Represents referencing a global variable.
+#
+# $foo
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#7183
+class Prism::GlobalVariableReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#7188
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7194
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7199
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7209
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7204
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#7214
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7199
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7225
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7230
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#7185
+ 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#7250
+ 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 writing to a global variable in a context that doesn't have an explicit value.
+#
+# $foo, $bar = baz
+# ^^^^ ^^^^
+#
+# source://prism//lib/prism/node.rb#7269
+class Prism::GlobalVariableTargetNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#7274
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7280
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7285
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7295
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7290
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#7300
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7285
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7311
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7316
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#7271
+ 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#7336
+ 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#7346
+ def type; end
+ end
+end
+
+# Represents writing to a global variable.
+#
+# $foo = 1
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7355
+class Prism::GlobalVariableWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#7369
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ value: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7378
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7383
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7393
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7388
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> GlobalVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#7398
+ sig { params(params: T.untyped).returns(Prism::GlobalVariableWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7383
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7412
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7422
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#7357
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7360
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#7417
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7366
+ 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#7446
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#7363
+ 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#7456
+ def type; end
+ end
+end
+
+# Represents a hash literal.
+#
+# { a => b }
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7465
+class Prism::HashNode < ::Prism::Node
+ # def initialize: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> void
+ #
+ # @return [HashNode] a new instance of HashNode
+ #
+ # source://prism//lib/prism/node.rb#7476
+ sig do
+ params(
+ opening_loc: Prism::Location,
+ elements: T::Array[Prism::Node],
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(opening_loc, elements, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7484
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7489
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#7527
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7473
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7499
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7494
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> HashNode
+ #
+ # source://prism//lib/prism/node.rb#7504
+ sig { params(params: T.untyped).returns(Prism::HashNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7489
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7517
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader elements: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7470
+ sig { returns(T::Array[Prism::Node]) }
+ def elements; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7532
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#7522
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#7467
+ 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#7554
+ 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#7564
+ 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#7576
+class Prism::HashPatternNode < ::Prism::Node
+ # def initialize: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+ #
+ # @return [HashPatternNode] a new instance of HashPatternNode
+ #
+ # source://prism//lib/prism/node.rb#7593
+ sig do
+ params(
+ constant: T.nilable(Prism::Node),
+ elements: T::Array[Prism::Node],
+ rest: T.nilable(Prism::Node),
+ opening_loc: T.nilable(Prism::Location),
+ closing_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(constant, elements, rest, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7603
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7608
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#7652
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#7590
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7622
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7613
+ def compact_child_nodes; end
+
+ # attr_reader constant: Node?
+ #
+ # source://prism//lib/prism/node.rb#7578
+ sig { returns(T.nilable(Prism::Node)) }
+ def constant; end
+
+ # def copy: (**params) -> HashPatternNode
+ #
+ # source://prism//lib/prism/node.rb#7627
+ sig { params(params: T.untyped).returns(Prism::HashPatternNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7608
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7642
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader elements: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7581
+ sig { returns(T::Array[Prism::Node]) }
+ def elements; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7657
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#7647
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#7587
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#7584
+ 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#7691
+ 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#7701
+ def type; end
+ end
+end
+
+# source://prism//lib/prism/node_ext.rb#35
+module Prism::HeredocQuery
+ # Returns true if this node was represented as a heredoc in the source code.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node_ext.rb#37
+ def heredoc?; end
+end
+
+# Represents the use of the `if` keyword, either in the block form or the modifier form.
+#
+# bar if foo
+# ^^^^^^^^^^
+#
+# if foo then bar end
+# ^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#7713
+class Prism::IfNode < ::Prism::Node
+ # def initialize: (if_keyword_loc: Location?, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+ #
+ # @return [IfNode] a new instance of IfNode
+ #
+ # source://prism//lib/prism/node.rb#7733
+ 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
+ ).void
+ end
+ def initialize(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7744
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7753
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7767
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7758
+ def compact_child_nodes; end
+
+ # attr_reader consequent: Node?
+ #
+ # source://prism//lib/prism/node.rb#7727
+ sig { returns(T.nilable(Prism::Node)) }
+ def consequent; end
+
+ # def copy: (**params) -> IfNode
+ #
+ # source://prism//lib/prism/node.rb#7772
+ sig { params(params: T.untyped).returns(Prism::IfNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7753
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7788
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#7803
+ sig { returns(T.nilable(String)) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#7730
+ sig { returns(T.nilable(Prism::Location)) }
+ def end_keyword_loc; end
+
+ # def if_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#7793
+ sig { returns(T.nilable(String)) }
+ def if_keyword; end
+
+ # attr_reader if_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#7715
+ sig { returns(T.nilable(Prism::Location)) }
+ def if_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7808
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader predicate: Node
+ #
+ # source://prism//lib/prism/node.rb#7718
+ sig { returns(Prism::Node) }
+ def predicate; end
+
+ # source://prism//lib/prism/node.rb#7748
+ def set_newline_flag(newline_marked); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#7724
+ sig { returns(T.nilable(Prism::StatementsNode)) }
+ def statements; end
+
+ # def then_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#7798
+ sig { returns(T.nilable(String)) }
+ def then_keyword; end
+
+ # attr_reader then_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#7721
+ 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#7844
+ 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#7854
+ def type; end
+ end
+end
+
+# Represents an imaginary number literal.
+#
+# 1.0i
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#7863
+class Prism::ImaginaryNode < ::Prism::Node
+ # def initialize: (numeric: Node, location: Location) -> void
+ #
+ # @return [ImaginaryNode] a new instance of ImaginaryNode
+ #
+ # source://prism//lib/prism/node.rb#7868
+ sig { params(numeric: Prism::Node, location: Prism::Location).void }
+ def initialize(numeric, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7874
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7879
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7889
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7884
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ImaginaryNode
+ #
+ # source://prism//lib/prism/node.rb#7894
+ sig { params(params: T.untyped).returns(Prism::ImaginaryNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7879
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7905
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#7910
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader numeric: Node
+ #
+ # source://prism//lib/prism/node.rb#7865
+ sig { returns(Prism::Node) }
+ def numeric; end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#7931
+ def type; end
+
+ # Returns the value of the node as a Ruby Complex.
+ #
+ # source://prism//lib/prism/node_ext.rb#69
+ def value; end
+
+ class << self
+ # Similar to #type, this method returns a symbol that you can use for
+ # splitting on the type of the node without having to do a long === chain.
+ # Note that like #type, it will still be slower than using == for a single
+ # class, but should be faster in a case statement or an array comparison.
+ #
+ # def self.type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#7941
+ 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: }
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#7954
+class Prism::ImplicitNode < ::Prism::Node
+ # def initialize: (value: Node, location: Location) -> void
+ #
+ # @return [ImplicitNode] a new instance of ImplicitNode
+ #
+ # source://prism//lib/prism/node.rb#7959
+ sig { params(value: Prism::Node, location: Prism::Location).void }
+ def initialize(value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#7965
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7970
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#7980
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#7975
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ImplicitNode
+ #
+ # source://prism//lib/prism/node.rb#7985
+ sig { params(params: T.untyped).returns(Prism::ImplicitNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#7970
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#7996
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8001
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#8022
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#7956
+ 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#8032
+ 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#8050
+class Prism::ImplicitRestNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [ImplicitRestNode] a new instance of ImplicitRestNode
+ #
+ # source://prism//lib/prism/node.rb#8052
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8057
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8062
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8072
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8067
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ImplicitRestNode
+ #
+ # source://prism//lib/prism/node.rb#8077
+ sig { params(params: T.untyped).returns(Prism::ImplicitRestNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8062
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8087
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8092
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#8111
+ 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#8121
+ 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#8130
+class Prism::InNode < ::Prism::Node
+ # def initialize: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void
+ #
+ # @return [InNode] a new instance of InNode
+ #
+ # source://prism//lib/prism/node.rb#8144
+ sig do
+ params(
+ 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(pattern, statements, in_loc, then_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8153
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8158
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8171
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8163
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InNode
+ #
+ # source://prism//lib/prism/node.rb#8176
+ sig { params(params: T.untyped).returns(Prism::InNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8158
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8190
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def in: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8195
+ sig { returns(String) }
+ def in; end
+
+ # attr_reader in_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8138
+ sig { returns(Prism::Location) }
+ def in_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8205
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader pattern: Node
+ #
+ # source://prism//lib/prism/node.rb#8132
+ sig { returns(Prism::Node) }
+ def pattern; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#8135
+ sig { returns(T.nilable(Prism::StatementsNode)) }
+ def statements; end
+
+ # def then: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#8200
+ sig { returns(T.nilable(String)) }
+ def then; end
+
+ # attr_reader then_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#8141
+ 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#8234
+ 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#8244
+ 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#8253
+class Prism::IndexAndWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8282
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8296
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#8267
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8355
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#8273
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#8360
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#8261
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8301
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8370
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8270
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8316
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8306
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> IndexAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8321
+ sig { params(params: T.untyped).returns(Prism::IndexAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8301
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8340
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8380
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8365
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8264
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8375
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8276
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#8258
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8345
+ 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#8425
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#8279
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8350
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#8255
+ 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#8435
+ 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#8444
+class Prism::IndexOperatorWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8476
+ 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: Symbol,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8491
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#8458
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8551
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#8464
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#8556
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#8452
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8496
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8566
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8461
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8511
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8501
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> IndexOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8516
+ sig { params(params: T.untyped).returns(Prism::IndexOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8496
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8536
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8571
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8561
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8455
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#8467
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8470
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#8449
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8541
+ 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#8617
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#8473
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8546
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#8446
+ 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#8627
+ 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#8636
+class Prism::IndexOrWriteNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8665
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8679
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#8650
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8738
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#8656
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def call_operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#8743
+ sig { returns(T.nilable(String)) }
+ def call_operator; end
+
+ # attr_reader call_operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#8644
+ sig { returns(T.nilable(Prism::Location)) }
+ def call_operator_loc; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8684
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8753
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8653
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8699
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8689
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> IndexOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#8704
+ sig { params(params: T.untyped).returns(Prism::IndexOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8684
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8723
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8763
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8748
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8647
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8758
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8659
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader receiver: Node?
+ #
+ # source://prism//lib/prism/node.rb#8641
+ sig { returns(T.nilable(Prism::Node)) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8728
+ 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#8808
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#8662
+ sig { returns(Prism::Node) }
+ def value; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8733
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#8638
+ 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#8818
+ 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#8835
+class Prism::IndexTargetNode < ::Prism::Node
+ # def initialize: (flags: Integer, receiver: Node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, location: Location) -> void
+ #
+ # @return [IndexTargetNode] a new instance of IndexTargetNode
+ #
+ # source://prism//lib/prism/node.rb#8855
+ 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
+ ).void
+ end
+ def initialize(flags, receiver, opening_loc, arguments, closing_loc, block, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#8866
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#8846
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def attribute_write?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8921
+ sig { returns(T::Boolean) }
+ def attribute_write?; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#8852
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8871
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8931
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8849
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#8885
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#8876
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> IndexTargetNode
+ #
+ # source://prism//lib/prism/node.rb#8890
+ sig { params(params: T.untyped).returns(Prism::IndexTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#8871
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#8906
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#8936
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#8926
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8843
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader receiver: Node
+ #
+ # source://prism//lib/prism/node.rb#8840
+ sig { returns(Prism::Node) }
+ def receiver; end
+
+ # def safe_navigation?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8911
+ 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#8973
+ def type; end
+
+ # def variable_call?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#8916
+ sig { returns(T::Boolean) }
+ def variable_call?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#8837
+ 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#8983
+ 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#245
+class Prism::InlineComment < ::Prism::Comment
+ # Returns a string representation of this comment.
+ #
+ # source://prism//lib/prism/parse_result.rb#253
+ def inspect; end
+
+ # Returns true if this comment happens on the same line as other code and
+ # false if the comment is by itself.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/parse_result.rb#248
+ sig { override.returns(T::Boolean) }
+ def trailing?; end
+end
+
+# Represents the use of the `&&=` operator for assignment to an instance variable.
+#
+# @target &&= value
+# ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#8992
+class Prism::InstanceVariableAndWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9006
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9015
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9020
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9030
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9025
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9035
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9020
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9049
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9059
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#8994
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#8997
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#9054
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9000
+ 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#9083
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#9003
+ 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#9093
+ 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#9102
+class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+ #
+ # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9119
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ operator: Symbol,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, operator, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9129
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9134
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9144
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9139
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9149
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9134
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9164
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9169
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9104
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9107
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9116
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9110
+ 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#9194
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#9113
+ 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#9204
+ 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#9213
+class Prism::InstanceVariableOrWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9227
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9236
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9241
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9251
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9246
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9256
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9241
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9270
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9280
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9215
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9218
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#9275
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9221
+ 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#9304
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#9224
+ 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#9314
+ def type; end
+ end
+end
+
+# Represents referencing an instance variable.
+#
+# @foo
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#9323
+class Prism::InstanceVariableReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#9328
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9334
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9339
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9349
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9344
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#9354
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9339
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9365
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9370
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9325
+ 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#9390
+ 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#9400
+ 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#9409
+class Prism::InstanceVariableTargetNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#9414
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9420
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9425
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9435
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9430
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#9440
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9425
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9451
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9456
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9411
+ 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#9476
+ 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#9486
+ def type; end
+ end
+end
+
+# Represents writing to an instance variable.
+#
+# @foo = 1
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9495
+class Prism::InstanceVariableWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9509
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ value: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9518
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9523
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9533
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9528
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InstanceVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#9538
+ sig { params(params: T.untyped).returns(Prism::InstanceVariableWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9523
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9552
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9562
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#9497
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9500
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#9557
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9506
+ 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#9586
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#9503
+ 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#9596
+ def type; end
+ end
+end
+
+# Flags for integer nodes that correspond to the base of the integer.
+#
+# source://prism//lib/prism/node.rb#17310
+module Prism::IntegerBaseFlags; end
+
+# 0b prefix
+#
+# source://prism//lib/prism/node.rb#17312
+Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
+
+# 0d or no prefix
+#
+# source://prism//lib/prism/node.rb#17315
+Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0x prefix
+#
+# source://prism//lib/prism/node.rb#17321
+Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
+
+# 0o or 0 prefix
+#
+# source://prism//lib/prism/node.rb#17318
+Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
+
+# Represents an integer number literal.
+#
+# 1
+# ^
+#
+# source://prism//lib/prism/node.rb#9605
+class Prism::IntegerNode < ::Prism::Node
+ # def initialize: (flags: Integer, location: Location) -> void
+ #
+ # @return [IntegerNode] a new instance of IntegerNode
+ #
+ # source://prism//lib/prism/node.rb#9610
+ sig { params(flags: Integer, location: Prism::Location).void }
+ def initialize(flags, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9616
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def binary?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9652
+ sig { returns(T::Boolean) }
+ def binary?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9621
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9631
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9626
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> IntegerNode
+ #
+ # source://prism//lib/prism/node.rb#9636
+ sig { params(params: T.untyped).returns(Prism::IntegerNode) }
+ def copy(**params); end
+
+ # def decimal?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9657
+ sig { returns(T::Boolean) }
+ def decimal?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9621
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9647
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def hexadecimal?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9667
+ sig { returns(T::Boolean) }
+ def hexadecimal?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9672
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def octal?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9662
+ 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#9693
+ def type; end
+
+ # Returns the value of the node as a Ruby Integer.
+ #
+ # source://prism//lib/prism/node_ext.rb#76
+ def value; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#9607
+ 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#9703
+ 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#9714
+class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
+ include ::Prism::RegularExpressionOptions
+
+ # def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+ #
+ # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
+ #
+ # source://prism//lib/prism/node.rb#9728
+ sig do
+ params(
+ flags: Integer,
+ opening_loc: Prism::Location,
+ parts: T::Array[Prism::Node],
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, opening_loc, parts, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9737
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def ascii_8bit?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9806
+ sig { returns(T::Boolean) }
+ def ascii_8bit?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9747
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#9841
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9725
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9757
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9752
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InterpolatedMatchLastLineNode
+ #
+ # source://prism//lib/prism/node.rb#9762
+ sig { params(params: T.untyped).returns(Prism::InterpolatedMatchLastLineNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9747
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9776
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def euc_jp?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9801
+ sig { returns(T::Boolean) }
+ def euc_jp?; end
+
+ # def extended?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9786
+ sig { returns(T::Boolean) }
+ def extended?; end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9826
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_us_ascii_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9831
+ sig { returns(T::Boolean) }
+ def forced_us_ascii_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9821
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def ignore_case?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9781
+ sig { returns(T::Boolean) }
+ def ignore_case?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#9846
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def multi_line?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9791
+ sig { returns(T::Boolean) }
+ def multi_line?; end
+
+ # def once?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9796
+ sig { returns(T::Boolean) }
+ def once?; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#9836
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9719
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader parts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9722
+ sig { returns(T::Array[Prism::Node]) }
+ def parts; end
+
+ # source://prism//lib/prism/node.rb#9741
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#9870
+ def type; end
+
+ # def utf_8?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9816
+ sig { returns(T::Boolean) }
+ def utf_8?; end
+
+ # def windows_31j?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9811
+ sig { returns(T::Boolean) }
+ def windows_31j?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#9716
+ 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#9880
+ def type; end
+ end
+end
+
+# Represents a regular expression literal that contains interpolation.
+#
+# /foo #{bar} baz/
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#9889
+class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
+ include ::Prism::RegularExpressionOptions
+
+ # def initialize: (flags: Integer, opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+ #
+ # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#9903
+ sig do
+ params(
+ flags: Integer,
+ opening_loc: Prism::Location,
+ parts: T::Array[Prism::Node],
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, opening_loc, parts, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#9912
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def ascii_8bit?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9981
+ sig { returns(T::Boolean) }
+ def ascii_8bit?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9922
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10016
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9900
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#9932
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9927
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InterpolatedRegularExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#9937
+ sig { params(params: T.untyped).returns(Prism::InterpolatedRegularExpressionNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#9922
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#9951
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def euc_jp?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9976
+ sig { returns(T::Boolean) }
+ def euc_jp?; end
+
+ # def extended?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9961
+ sig { returns(T::Boolean) }
+ def extended?; end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#10001
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_us_ascii_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#10006
+ sig { returns(T::Boolean) }
+ def forced_us_ascii_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9996
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def ignore_case?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9956
+ sig { returns(T::Boolean) }
+ def ignore_case?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10021
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def multi_line?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9966
+ sig { returns(T::Boolean) }
+ def multi_line?; end
+
+ # def once?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9971
+ sig { returns(T::Boolean) }
+ def once?; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10011
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#9894
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader parts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#9897
+ sig { returns(T::Array[Prism::Node]) }
+ def parts; end
+
+ # source://prism//lib/prism/node.rb#9916
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#10045
+ def type; end
+
+ # def utf_8?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9991
+ sig { returns(T::Boolean) }
+ def utf_8?; end
+
+ # def windows_31j?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#9986
+ sig { returns(T::Boolean) }
+ def windows_31j?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#9891
+ 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#10055
+ def type; end
+ end
+end
+
+# Represents a string literal that contains interpolation.
+#
+# "foo #{bar} baz"
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10064
+class Prism::InterpolatedStringNode < ::Prism::Node
+ include ::Prism::HeredocQuery
+
+ # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
+ #
+ # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
+ #
+ # source://prism//lib/prism/node.rb#10075
+ sig do
+ params(
+ opening_loc: T.nilable(Prism::Location),
+ parts: T::Array[Prism::Node],
+ closing_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(opening_loc, parts, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10083
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10093
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#10131
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#10072
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10103
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10098
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InterpolatedStringNode
+ #
+ # source://prism//lib/prism/node.rb#10108
+ sig { params(params: T.untyped).returns(Prism::InterpolatedStringNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10093
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10121
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10136
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#10126
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#10066
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader parts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10069
+ sig { returns(T::Array[Prism::Node]) }
+ def parts; end
+
+ # source://prism//lib/prism/node.rb#10087
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#10158
+ 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#10168
+ def type; end
+ end
+end
+
+# Represents a symbol literal that contains interpolation.
+#
+# :"foo #{bar} baz"
+# ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10177
+class Prism::InterpolatedSymbolNode < ::Prism::Node
+ # def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
+ #
+ # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
+ #
+ # source://prism//lib/prism/node.rb#10188
+ sig do
+ params(
+ opening_loc: T.nilable(Prism::Location),
+ parts: T::Array[Prism::Node],
+ closing_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(opening_loc, parts, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10196
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10206
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#10244
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#10185
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10216
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10211
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InterpolatedSymbolNode
+ #
+ # source://prism//lib/prism/node.rb#10221
+ sig { params(params: T.untyped).returns(Prism::InterpolatedSymbolNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10206
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10234
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10249
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#10239
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#10179
+ sig { returns(T.nilable(Prism::Location)) }
+ def opening_loc; end
+
+ # attr_reader parts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10182
+ sig { returns(T::Array[Prism::Node]) }
+ def parts; end
+
+ # source://prism//lib/prism/node.rb#10200
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#10271
+ 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#10281
+ def type; end
+ end
+end
+
+# Represents an xstring literal that contains interpolation.
+#
+# `foo #{bar} baz`
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10290
+class Prism::InterpolatedXStringNode < ::Prism::Node
+ include ::Prism::HeredocQuery
+
+ # def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+ #
+ # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
+ #
+ # source://prism//lib/prism/node.rb#10301
+ sig do
+ params(
+ opening_loc: Prism::Location,
+ parts: T::Array[Prism::Node],
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(opening_loc, parts, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10309
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10319
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10357
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10298
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10329
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10324
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> InterpolatedXStringNode
+ #
+ # source://prism//lib/prism/node.rb#10334
+ sig { params(params: T.untyped).returns(Prism::InterpolatedXStringNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10319
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10347
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10362
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10352
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10292
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader parts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10295
+ sig { returns(T::Array[Prism::Node]) }
+ def parts; end
+
+ # source://prism//lib/prism/node.rb#10313
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#10384
+ 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#10394
+ def type; end
+ end
+end
+
+# Represents a hash literal without opening and closing braces.
+#
+# foo(a: b)
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#10403
+class Prism::KeywordHashNode < ::Prism::Node
+ # def initialize: (flags: Integer, elements: Array[Node], location: Location) -> void
+ #
+ # @return [KeywordHashNode] a new instance of KeywordHashNode
+ #
+ # source://prism//lib/prism/node.rb#10411
+ sig { params(flags: Integer, elements: T::Array[Prism::Node], location: Prism::Location).void }
+ def initialize(flags, elements, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10418
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10423
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10433
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10428
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> KeywordHashNode
+ #
+ # source://prism//lib/prism/node.rb#10438
+ sig { params(params: T.untyped).returns(Prism::KeywordHashNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10423
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10450
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader elements: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10408
+ sig { returns(T::Array[Prism::Node]) }
+ def elements; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10460
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def static_keys?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#10455
+ sig { returns(T::Boolean) }
+ def static_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#10482
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#10405
+ 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#10492
+ def type; end
+ end
+end
+
+# Flags for keyword hash nodes.
+#
+# source://prism//lib/prism/node.rb#17325
+module Prism::KeywordHashNodeFlags; end
+
+# a keyword hash which only has `AssocNode` elements all with static literal keys, which means the elements can be treated as keyword arguments
+#
+# source://prism//lib/prism/node.rb#17327
+Prism::KeywordHashNodeFlags::STATIC_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#10502
+class Prism::KeywordRestParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode
+ #
+ # source://prism//lib/prism/node.rb#10513
+ sig do
+ params(
+ name: T.nilable(Symbol),
+ name_loc: T.nilable(Prism::Location),
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10521
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10526
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10536
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10531
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> KeywordRestParameterNode
+ #
+ # source://prism//lib/prism/node.rb#10541
+ sig { params(params: T.untyped).returns(Prism::KeywordRestParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10526
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10554
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10564
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol?
+ #
+ # source://prism//lib/prism/node.rb#10504
+ sig { returns(T.nilable(Symbol)) }
+ def name; end
+
+ # attr_reader name_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#10507
+ sig { returns(T.nilable(Prism::Location)) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10559
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10510
+ 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#10590
+ 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#10600
+ def type; end
+ end
+end
+
+# Represents using a lambda literal (not the lambda method call).
+#
+# ->(value) { value * 2 }
+# ^^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10609
+class Prism::LambdaNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], locals_body_index: Integer, operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Node?, body: Node?, location: Location) -> void
+ #
+ # @return [LambdaNode] a new instance of LambdaNode
+ #
+ # source://prism//lib/prism/node.rb#10632
+ sig do
+ params(
+ locals: T::Array[Symbol],
+ locals_body_index: Integer,
+ 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(locals, locals_body_index, operator_loc, opening_loc, closing_loc, parameters, body, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10644
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#10629
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10649
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10699
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10623
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10662
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10654
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LambdaNode
+ #
+ # source://prism//lib/prism/node.rb#10667
+ sig { params(params: T.untyped).returns(Prism::LambdaNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10649
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10684
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10704
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#10611
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # attr_reader locals_body_index: Integer
+ #
+ # source://prism//lib/prism/node.rb#10614
+ sig { returns(Integer) }
+ def locals_body_index; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10694
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10620
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10689
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10617
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader parameters: Node?
+ #
+ # source://prism//lib/prism/node.rb#10626
+ 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#10740
+ 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#10750
+ 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#11
+class Prism::LexCompat
+ # @return [LexCompat] a new instance of LexCompat
+ #
+ # source://prism//lib/prism/lex_compat.rb#599
+ def initialize(source, **options); end
+
+ # Returns the value of attribute options.
+ #
+ # source://prism//lib/prism/lex_compat.rb#597
+ def options; end
+
+ # source://prism//lib/prism/lex_compat.rb#604
+ def result; end
+
+ # Returns the value of attribute source.
+ #
+ # source://prism//lib/prism/lex_compat.rb#597
+ def source; end
+end
+
+# Ripper doesn't include the rest of the token in the event, so we need to
+# trim it down to just the content on the first line when comparing.
+#
+# source://prism//lib/prism/lex_compat.rb#210
+class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
+ # source://prism//lib/prism/lex_compat.rb#211
+ def ==(other); end
+end
+
+# A heredoc in this case is a list of tokens that belong to the body of the
+# heredoc that should be appended onto the list of tokens when the heredoc
+# closes.
+#
+# source://prism//lib/prism/lex_compat.rb#271
+module Prism::LexCompat::Heredoc
+ class << self
+ # Here we will split between the two types of heredocs and return the
+ # object that will store their tokens.
+ #
+ # source://prism//lib/prism/lex_compat.rb#583
+ def build(opening); end
+ end
+end
+
+# Dash heredocs are a little more complicated. They are a list of tokens
+# that need to be split on "\\\n" to mimic Ripper's behavior. We also need
+# to keep track of the state that the heredoc was opened in.
+#
+# source://prism//lib/prism/lex_compat.rb#295
+class Prism::LexCompat::Heredoc::DashHeredoc
+ # @return [DashHeredoc] a new instance of DashHeredoc
+ #
+ # source://prism//lib/prism/lex_compat.rb#298
+ def initialize(split); end
+
+ # source://prism//lib/prism/lex_compat.rb#303
+ def <<(token); end
+
+ # source://prism//lib/prism/lex_compat.rb#296
+ def split; end
+
+ # source://prism//lib/prism/lex_compat.rb#307
+ def to_a; end
+
+ # source://prism//lib/prism/lex_compat.rb#296
+ def tokens; end
+end
+
+# Heredocs that are dedenting heredocs are a little more complicated.
+# Ripper outputs on_ignored_sp tokens for the whitespace that is being
+# removed from the output. prism only modifies the node itself and keeps
+# the token the same. This simplifies prism, but makes comparing against
+# Ripper much harder because there is a length mismatch.
+#
+# Fortunately, we already have to pull out the heredoc tokens in order to
+# insert them into the stream in the correct order. As such, we can do
+# some extra manipulation on the tokens to make them match Ripper's
+# output by mirroring the dedent logic that Ripper uses.
+#
+# source://prism//lib/prism/lex_compat.rb#354
+class Prism::LexCompat::Heredoc::DedentingHeredoc
+ # @return [DedentingHeredoc] a new instance of DedentingHeredoc
+ #
+ # source://prism//lib/prism/lex_compat.rb#359
+ def initialize; end
+
+ # As tokens are coming in, we track the minimum amount of common leading
+ # whitespace on plain string content tokens. This allows us to later
+ # remove that amount of whitespace from the beginning of each line.
+ #
+ # source://prism//lib/prism/lex_compat.rb#370
+ def <<(token); end
+
+ # Returns the value of attribute dedent.
+ #
+ # source://prism//lib/prism/lex_compat.rb#357
+ def dedent; end
+
+ # Returns the value of attribute dedent_next.
+ #
+ # source://prism//lib/prism/lex_compat.rb#357
+ def dedent_next; end
+
+ # Returns the value of attribute embexpr_balance.
+ #
+ # source://prism//lib/prism/lex_compat.rb#357
+ def embexpr_balance; end
+
+ # source://prism//lib/prism/lex_compat.rb#407
+ def to_a; end
+
+ # Returns the value of attribute tokens.
+ #
+ # source://prism//lib/prism/lex_compat.rb#357
+ def tokens; end
+end
+
+# source://prism//lib/prism/lex_compat.rb#355
+Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# Heredocs that are no dash or tilde heredocs are just a list of tokens.
+# We need to keep them around so that we can insert them in the correct
+# order back into the token stream and set the state of the last token to
+# the state that the heredoc was opened in.
+#
+# source://prism//lib/prism/lex_compat.rb#276
+class Prism::LexCompat::Heredoc::PlainHeredoc
+ # @return [PlainHeredoc] a new instance of PlainHeredoc
+ #
+ # source://prism//lib/prism/lex_compat.rb#279
+ def initialize; end
+
+ # source://prism//lib/prism/lex_compat.rb#283
+ def <<(token); end
+
+ # source://prism//lib/prism/lex_compat.rb#287
+ def to_a; end
+
+ # source://prism//lib/prism/lex_compat.rb#277
+ def tokens; end
+end
+
+# Ident tokens for the most part are exactly the same, except sometimes we
+# know an ident is a local when ripper doesn't (when they are introduced
+# through named captures in regular expressions). In that case we don't
+# compare the state.
+#
+# source://prism//lib/prism/lex_compat.rb#228
+class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
+ # source://prism//lib/prism/lex_compat.rb#229
+ def ==(other); end
+end
+
+# Tokens where state should be ignored
+# used for :on_comment, :on_heredoc_end, :on_embexpr_end
+#
+# source://prism//lib/prism/lex_compat.rb#218
+class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
+ # source://prism//lib/prism/lex_compat.rb#219
+ def ==(other); end
+end
+
+# Ignored newlines can occasionally have a LABEL state attached to them, so
+# we compare the state differently here.
+#
+# source://prism//lib/prism/lex_compat.rb#239
+class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
+ # source://prism//lib/prism/lex_compat.rb#240
+ def ==(other); end
+end
+
+# If we have an identifier that follows a method name like:
+#
+# def foo bar
+#
+# then Ripper will mark bar as END|LABEL if there is a local in a parent
+# scope named bar because it hasn't pushed the local table yet. We do this
+# more accurately, so we need to allow comparing against both END and
+# END|LABEL.
+#
+# source://prism//lib/prism/lex_compat.rb#259
+class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
+ # source://prism//lib/prism/lex_compat.rb#260
+ def ==(other); end
+end
+
+# This is a mapping of prism token types to Ripper token types. This is a
+# many-to-one mapping because we split up our token types, whereas Ripper
+# tends to group them.
+#
+# source://prism//lib/prism/lex_compat.rb#15
+Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
+
+# When we produce tokens, we produce the same arrays that Ripper does.
+# However, we add a couple of convenience methods onto them to make them a
+# little easier to work with. We delegate all other methods to the array.
+#
+# source://prism//lib/prism/lex_compat.rb#186
+class Prism::LexCompat::Token < ::SimpleDelegator
+ # The type of the token.
+ #
+ # source://prism//lib/prism/lex_compat.rb#193
+ def event; end
+
+ # The location of the token in the source.
+ #
+ # source://prism//lib/prism/lex_compat.rb#188
+ def location; end
+
+ # The state of the lexer when this token was produced.
+ #
+ # source://prism//lib/prism/lex_compat.rb#203
+ def state; end
+
+ # The slice of the source that this token represents.
+ #
+ # source://prism//lib/prism/lex_compat.rb#198
+ def value; end
+end
+
+# This is a class that wraps the Ripper lexer to produce almost exactly the
+# same tokens.
+#
+# source://prism//lib/prism/lex_compat.rb#852
+class Prism::LexRipper
+ # @return [LexRipper] a new instance of LexRipper
+ #
+ # source://prism//lib/prism/lex_compat.rb#855
+ def initialize(source); end
+
+ # source://prism//lib/prism/lex_compat.rb#859
+ def result; end
+
+ # source://prism//lib/prism/lex_compat.rb#853
+ def source; end
+end
+
+# Represents the use of the `&&=` operator for assignment to a local variable.
+#
+# target &&= value
+# ^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#10759
+class Prism::LocalVariableAndWriteNode < ::Prism::Node
+ # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+ #
+ # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#10776
+ sig do
+ params(
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ name: Symbol,
+ depth: Integer,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name_loc, operator_loc, value, name, depth, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10786
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10791
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10801
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10796
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableAndWriteNode
+ #
+ # source://prism//lib/prism/node.rb#10806
+ sig { params(params: T.untyped).returns(Prism::LocalVariableAndWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10791
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10821
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#10773
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10831
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#10770
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10761
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#10826
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10764
+ 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#10856
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#10767
+ 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#10866
+ 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#10875
+class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
+ # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void
+ #
+ # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#10895
+ sig do
+ params(
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ name: Symbol,
+ operator: Symbol,
+ depth: Integer,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name_loc, operator_loc, value, name, operator, depth, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#10906
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10911
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#10921
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#10916
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableOperatorWriteNode
+ #
+ # source://prism//lib/prism/node.rb#10926
+ sig { params(params: T.untyped).returns(Prism::LocalVariableOperatorWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#10911
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#10942
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#10892
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#10947
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#10886
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10877
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # attr_reader operator: Symbol
+ #
+ # source://prism//lib/prism/node.rb#10889
+ sig { returns(Symbol) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10880
+ 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#10973
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#10883
+ 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#10983
+ 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#10992
+class Prism::LocalVariableOrWriteNode < ::Prism::Node
+ # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+ #
+ # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11009
+ sig do
+ params(
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ name: Symbol,
+ depth: Integer,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name_loc, operator_loc, value, name, depth, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11019
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11024
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11034
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11029
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableOrWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11039
+ sig { params(params: T.untyped).returns(Prism::LocalVariableOrWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11024
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11054
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#11006
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11064
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#11003
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10994
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11059
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#10997
+ 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#11089
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#11000
+ 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#11099
+ 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#11110
+class Prism::LocalVariableReadNode < ::Prism::Node
+ # def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+ #
+ # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#11118
+ sig { params(name: Symbol, depth: Integer, location: Prism::Location).void }
+ def initialize(name, depth, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11125
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11130
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11140
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11135
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableReadNode
+ #
+ # source://prism//lib/prism/node.rb#11145
+ sig { params(params: T.untyped).returns(Prism::LocalVariableReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11130
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11157
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#11115
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11162
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#11112
+ 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#11183
+ 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#11193
+ 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#11202
+class Prism::LocalVariableTargetNode < ::Prism::Node
+ # def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+ #
+ # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#11210
+ sig { params(name: Symbol, depth: Integer, location: Prism::Location).void }
+ def initialize(name, depth, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11217
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11222
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11232
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11227
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableTargetNode
+ #
+ # source://prism//lib/prism/node.rb#11237
+ sig { params(params: T.untyped).returns(Prism::LocalVariableTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11222
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11249
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#11207
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11254
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#11204
+ 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#11275
+ 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#11285
+ def type; end
+ end
+end
+
+# Represents writing to a local variable.
+#
+# foo = 1
+# ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11294
+class Prism::LocalVariableWriteNode < ::Prism::Node
+ # def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11311
+ sig do
+ params(
+ name: Symbol,
+ depth: Integer,
+ name_loc: Prism::Location,
+ value: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, depth, name_loc, value, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11321
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11326
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11336
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11331
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> LocalVariableWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11341
+ sig { params(params: T.untyped).returns(Prism::LocalVariableWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11326
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11356
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader depth: Integer
+ #
+ # source://prism//lib/prism/node.rb#11299
+ sig { returns(Integer) }
+ def depth; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11366
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#11296
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11302
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11361
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11308
+ 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#11391
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#11305
+ 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#11401
+ def type; end
+ end
+end
+
+# This represents a location in the source.
+#
+# source://prism//lib/prism/parse_result.rb#91
+class Prism::Location
+ # Create a new location object with the given source, start byte offset, and
+ # byte length.
+ #
+ # @return [Location] a new instance of Location
+ #
+ # source://prism//lib/prism/parse_result.rb#108
+ 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#202
+ def ==(other); end
+
+ # The list of comments attached to this location
+ #
+ # source://prism//lib/prism/parse_result.rb#104
+ sig { returns(T::Array[Prism::Comment]) }
+ def comments; end
+
+ # Create a new location object with the given options.
+ #
+ # source://prism//lib/prism/parse_result.rb#116
+ sig { params(options: T.untyped).returns(Prism::Location) }
+ def copy(**options); end
+
+ # Implement the hash pattern matching interface for Location.
+ #
+ # source://prism//lib/prism/parse_result.rb#192
+ def deconstruct_keys(keys); end
+
+ # The column number in characters where this location ends from the start of
+ # the line.
+ #
+ # source://prism//lib/prism/parse_result.rb#187
+ def end_character_column; end
+
+ # The character offset from the beginning of the source where this location
+ # ends.
+ #
+ # source://prism//lib/prism/parse_result.rb#147
+ def end_character_offset; end
+
+ # The column number in bytes where this location ends from the start of the
+ # line.
+ #
+ # source://prism//lib/prism/parse_result.rb#181
+ sig { returns(Integer) }
+ def end_column; end
+
+ # The line number where this location ends.
+ #
+ # source://prism//lib/prism/parse_result.rb#163
+ sig { returns(Integer) }
+ def end_line; end
+
+ # The byte offset from the beginning of the source where this location ends.
+ #
+ # source://prism//lib/prism/parse_result.rb#141
+ sig { returns(Integer) }
+ def end_offset; end
+
+ # Returns a string representation of this location.
+ #
+ # source://prism//lib/prism/parse_result.rb#125
+ def inspect; end
+
+ # Returns a new location that stretches from this location to the given
+ # other location. Raises an error if this location is not before the other
+ # location or if they don't share the same source.
+ #
+ # source://prism//lib/prism/parse_result.rb#211
+ def join(other); end
+
+ # The length of this location in bytes.
+ #
+ # source://prism//lib/prism/parse_result.rb#101
+ def length; end
+
+ # Implement the pretty print interface for Location.
+ #
+ # source://prism//lib/prism/parse_result.rb#197
+ def pretty_print(q); end
+
+ # The source code that this location represents.
+ #
+ # source://prism//lib/prism/parse_result.rb#130
+ sig { returns(String) }
+ def slice; end
+
+ # The column number in characters where this location ends from the start of
+ # the line.
+ #
+ # source://prism//lib/prism/parse_result.rb#175
+ def start_character_column; end
+
+ # The character offset from the beginning of the source where this location
+ # starts.
+ #
+ # source://prism//lib/prism/parse_result.rb#136
+ def start_character_offset; end
+
+ # The column number in bytes where this location starts from the start of
+ # the line.
+ #
+ # source://prism//lib/prism/parse_result.rb#169
+ sig { returns(Integer) }
+ def start_column; end
+
+ # The line number where this location starts.
+ #
+ # source://prism//lib/prism/parse_result.rb#152
+ sig { returns(Integer) }
+ def start_line; end
+
+ # The content of the line where this location starts before this location.
+ #
+ # source://prism//lib/prism/parse_result.rb#157
+ def start_line_slice; end
+
+ # The byte offset from the beginning of the source where this location
+ # starts.
+ #
+ # source://prism//lib/prism/parse_result.rb#98
+ sig { returns(Integer) }
+ def start_offset; end
+
+ protected
+
+ # Returns the value of attribute source.
+ #
+ # source://prism//lib/prism/parse_result.rb#94
+ def source; end
+
+ class << self
+ # Returns a null location that does not correspond to a source and points to
+ # the beginning of the file. Useful for when you want a location object but
+ # do not care where it points.
+ #
+ # source://prism//lib/prism/parse_result.rb#221
+ def null; end
+ end
+end
+
+# Flags for while and until loop nodes.
+#
+# source://prism//lib/prism/node.rb#17331
+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#17333
+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#273
+class Prism::MagicComment
+ # Create a new magic comment object with the given key and value locations.
+ #
+ # @return [MagicComment] a new instance of MagicComment
+ #
+ # source://prism//lib/prism/parse_result.rb#281
+ def initialize(key_loc, value_loc); end
+
+ # Implement the hash pattern matching interface for MagicComment.
+ #
+ # source://prism//lib/prism/parse_result.rb#297
+ def deconstruct_keys(keys); end
+
+ # Returns a string representation of this magic comment.
+ #
+ # source://prism//lib/prism/parse_result.rb#302
+ def inspect; end
+
+ # Returns the key of the magic comment by slicing it from the source code.
+ #
+ # source://prism//lib/prism/parse_result.rb#287
+ def key; end
+
+ # A Location object representing the location of the key in the source.
+ #
+ # source://prism//lib/prism/parse_result.rb#275
+ def key_loc; end
+
+ # Returns the value of the magic comment by slicing it from the source code.
+ #
+ # source://prism//lib/prism/parse_result.rb#292
+ def value; end
+
+ # A Location object representing the location of the value in the source.
+ #
+ # source://prism//lib/prism/parse_result.rb#278
+ def value_loc; end
+end
+
+# Represents a regular expression literal used in the predicate of a
+# conditional to implicitly match against the last line read by an IO
+# object.
+#
+# if /foo/i then end
+# ^^^^^^
+#
+# source://prism//lib/prism/node.rb#11412
+class Prism::MatchLastLineNode < ::Prism::Node
+ include ::Prism::RegularExpressionOptions
+
+ # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+ #
+ # @return [MatchLastLineNode] a new instance of MatchLastLineNode
+ #
+ # source://prism//lib/prism/node.rb#11429
+ sig do
+ params(
+ flags: Integer,
+ opening_loc: Prism::Location,
+ content_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ unescaped: String,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11439
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def ascii_8bit?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11504
+ sig { returns(T::Boolean) }
+ def ascii_8bit?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11444
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11544
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11423
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11454
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11449
+ def compact_child_nodes; end
+
+ # def content: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11539
+ sig { returns(String) }
+ def content; end
+
+ # attr_reader content_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11420
+ sig { returns(Prism::Location) }
+ def content_loc; end
+
+ # def copy: (**params) -> MatchLastLineNode
+ #
+ # source://prism//lib/prism/node.rb#11459
+ sig { params(params: T.untyped).returns(Prism::MatchLastLineNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11444
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11474
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def euc_jp?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11499
+ sig { returns(T::Boolean) }
+ def euc_jp?; end
+
+ # def extended?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11484
+ sig { returns(T::Boolean) }
+ def extended?; end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11524
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_us_ascii_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11529
+ sig { returns(T::Boolean) }
+ def forced_us_ascii_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11519
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def ignore_case?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11479
+ sig { returns(T::Boolean) }
+ def ignore_case?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11549
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def multi_line?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11489
+ sig { returns(T::Boolean) }
+ def multi_line?; end
+
+ # def once?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11494
+ sig { returns(T::Boolean) }
+ def once?; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11534
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11417
+ 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#11574
+ def type; end
+
+ # attr_reader unescaped: String
+ #
+ # source://prism//lib/prism/node.rb#11426
+ sig { returns(String) }
+ def unescaped; end
+
+ # def utf_8?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11514
+ sig { returns(T::Boolean) }
+ def utf_8?; end
+
+ # def windows_31j?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#11509
+ sig { returns(T::Boolean) }
+ def windows_31j?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#11414
+ 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#11584
+ def type; end
+ end
+end
+
+# Represents the use of the modifier `in` operator.
+#
+# foo in bar
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11593
+class Prism::MatchPredicateNode < ::Prism::Node
+ # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [MatchPredicateNode] a new instance of MatchPredicateNode
+ #
+ # source://prism//lib/prism/node.rb#11604
+ sig do
+ params(
+ value: Prism::Node,
+ pattern: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(value, pattern, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11612
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11617
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11627
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11622
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MatchPredicateNode
+ #
+ # source://prism//lib/prism/node.rb#11632
+ sig { params(params: T.untyped).returns(Prism::MatchPredicateNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11617
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11645
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11655
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11650
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11601
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader pattern: Node
+ #
+ # source://prism//lib/prism/node.rb#11598
+ 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#11679
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#11595
+ 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#11689
+ def type; end
+ end
+end
+
+# Represents the use of the `=>` operator.
+#
+# foo => bar
+# ^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11698
+class Prism::MatchRequiredNode < ::Prism::Node
+ # def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [MatchRequiredNode] a new instance of MatchRequiredNode
+ #
+ # source://prism//lib/prism/node.rb#11709
+ sig do
+ params(
+ value: Prism::Node,
+ pattern: Prism::Node,
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(value, pattern, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11717
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11722
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11732
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11727
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MatchRequiredNode
+ #
+ # source://prism//lib/prism/node.rb#11737
+ sig { params(params: T.untyped).returns(Prism::MatchRequiredNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11722
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11750
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11760
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#11755
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11706
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader pattern: Node
+ #
+ # source://prism//lib/prism/node.rb#11703
+ 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#11784
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#11700
+ 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#11794
+ def type; end
+ end
+end
+
+# Represents writing local variables using a regular expression match with
+# named capture groups.
+#
+# /(?bar)/ =~ baz
+# ^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11804
+class Prism::MatchWriteNode < ::Prism::Node
+ # def initialize: (call: CallNode, targets: Array[Node], location: Location) -> void
+ #
+ # @return [MatchWriteNode] a new instance of MatchWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11812
+ sig { params(call: Prism::CallNode, targets: T::Array[Prism::Node], location: Prism::Location).void }
+ def initialize(call, targets, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11819
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader call: CallNode
+ #
+ # source://prism//lib/prism/node.rb#11806
+ sig { returns(Prism::CallNode) }
+ def call; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11824
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11834
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11829
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MatchWriteNode
+ #
+ # source://prism//lib/prism/node.rb#11839
+ sig { params(params: T.untyped).returns(Prism::MatchWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11824
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11851
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11856
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader targets: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11809
+ sig { returns(T::Array[Prism::Node]) }
+ def targets; end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#11878
+ 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#11888
+ 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#11895
+class Prism::MissingNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [MissingNode] a new instance of MissingNode
+ #
+ # source://prism//lib/prism/node.rb#11897
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#11902
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11907
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#11917
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#11912
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MissingNode
+ #
+ # source://prism//lib/prism/node.rb#11922
+ sig { params(params: T.untyped).returns(Prism::MissingNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#11907
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#11932
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#11937
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#11956
+ 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#11966
+ def type; end
+ end
+end
+
+# Represents a module declaration involving the `module` keyword.
+#
+# module Foo end
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#11975
+class Prism::ModuleNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
+ #
+ # @return [ModuleNode] a new instance of ModuleNode
+ #
+ # source://prism//lib/prism/node.rb#11995
+ 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
+ ).void
+ end
+ def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12006
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#11986
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12011
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12024
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12016
+ def compact_child_nodes; end
+
+ # attr_reader constant_path: Node
+ #
+ # source://prism//lib/prism/node.rb#11983
+ sig { returns(Prism::Node) }
+ def constant_path; end
+
+ # def copy: (**params) -> ModuleNode
+ #
+ # source://prism//lib/prism/node.rb#12029
+ sig { params(params: T.untyped).returns(Prism::ModuleNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12011
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12045
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12055
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11989
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12060
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#11977
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # def module_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12050
+ sig { returns(String) }
+ def module_keyword; end
+
+ # attr_reader module_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#11980
+ sig { returns(Prism::Location) }
+ def module_keyword_loc; end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#11992
+ 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#12091
+ 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#12101
+ def type; end
+ end
+end
+
+# Represents a multi-target expression.
+#
+# a, (b, c) = 1, 2, 3
+# ^^^^^^
+#
+# source://prism//lib/prism/node.rb#12110
+class Prism::MultiTargetNode < ::Prism::Node
+ # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
+ #
+ # @return [MultiTargetNode] a new instance of MultiTargetNode
+ #
+ # source://prism//lib/prism/node.rb#12127
+ sig do
+ params(
+ lefts: T::Array[Prism::Node],
+ rest: T.nilable(Prism::Node),
+ rights: T::Array[Prism::Node],
+ lparen_loc: T.nilable(Prism::Location),
+ rparen_loc: T.nilable(Prism::Location),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(lefts, rest, rights, lparen_loc, rparen_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12137
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12142
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12156
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12147
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MultiTargetNode
+ #
+ # source://prism//lib/prism/node.rb#12161
+ sig { params(params: T.untyped).returns(Prism::MultiTargetNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12142
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12176
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12191
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader lefts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12112
+ sig { returns(T::Array[Prism::Node]) }
+ def lefts; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#12181
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#12121
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # attr_reader rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#12115
+ sig { returns(T.nilable(Prism::Node)) }
+ def rest; end
+
+ # attr_reader rights: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12118
+ sig { returns(T::Array[Prism::Node]) }
+ def rights; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#12186
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#12124
+ 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#12220
+ 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#12230
+ 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#12239
+class Prism::MultiWriteNode < ::Prism::Node
+ # def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [MultiWriteNode] a new instance of MultiWriteNode
+ #
+ # source://prism//lib/prism/node.rb#12262
+ sig do
+ params(
+ lefts: T::Array[Prism::Node],
+ rest: T.nilable(Prism::Node),
+ rights: T::Array[Prism::Node],
+ 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(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12274
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12279
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12294
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12284
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> MultiWriteNode
+ #
+ # source://prism//lib/prism/node.rb#12299
+ sig { params(params: T.untyped).returns(Prism::MultiWriteNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12279
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12316
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12336
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader lefts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12241
+ sig { returns(T::Array[Prism::Node]) }
+ def lefts; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#12321
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#12250
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12331
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12256
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#12244
+ sig { returns(T.nilable(Prism::Node)) }
+ def rest; end
+
+ # attr_reader rights: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12247
+ sig { returns(T::Array[Prism::Node]) }
+ def rights; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#12326
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#12253
+ 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#12368
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#12259
+ 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#12378
+ 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#12
+class Prism::MutationCompiler < ::Prism::Compiler
+ # Copy a AliasGlobalVariableNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#14
+ def visit_alias_global_variable_node(node); end
+
+ # Copy a AliasMethodNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#19
+ def visit_alias_method_node(node); end
+
+ # Copy a AlternationPatternNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#24
+ def visit_alternation_pattern_node(node); end
+
+ # Copy a AndNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#29
+ def visit_and_node(node); end
+
+ # Copy a ArgumentsNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#34
+ def visit_arguments_node(node); end
+
+ # Copy a ArrayNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#39
+ def visit_array_node(node); end
+
+ # Copy a ArrayPatternNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#44
+ def visit_array_pattern_node(node); end
+
+ # Copy a AssocNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#49
+ def visit_assoc_node(node); end
+
+ # Copy a AssocSplatNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#54
+ def visit_assoc_splat_node(node); end
+
+ # Copy a BackReferenceReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#59
+ def visit_back_reference_read_node(node); end
+
+ # Copy a BeginNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#64
+ def visit_begin_node(node); end
+
+ # Copy a BlockArgumentNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#69
+ def visit_block_argument_node(node); end
+
+ # Copy a BlockLocalVariableNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#74
+ def visit_block_local_variable_node(node); end
+
+ # Copy a BlockNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#79
+ def visit_block_node(node); end
+
+ # Copy a BlockParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#84
+ def visit_block_parameter_node(node); end
+
+ # Copy a BlockParametersNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#89
+ def visit_block_parameters_node(node); end
+
+ # Copy a BreakNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#94
+ def visit_break_node(node); end
+
+ # Copy a CallAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#99
+ def visit_call_and_write_node(node); end
+
+ # Copy a CallNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#104
+ def visit_call_node(node); end
+
+ # Copy a CallOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#109
+ def visit_call_operator_write_node(node); end
+
+ # Copy a CallOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#114
+ def visit_call_or_write_node(node); end
+
+ # Copy a CallTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#119
+ def visit_call_target_node(node); end
+
+ # Copy a CapturePatternNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#124
+ def visit_capture_pattern_node(node); end
+
+ # Copy a CaseMatchNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#129
+ def visit_case_match_node(node); end
+
+ # Copy a CaseNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#134
+ def visit_case_node(node); end
+
+ # Copy a ClassNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#139
+ def visit_class_node(node); end
+
+ # Copy a ClassVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#144
+ def visit_class_variable_and_write_node(node); end
+
+ # Copy a ClassVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#149
+ def visit_class_variable_operator_write_node(node); end
+
+ # Copy a ClassVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#154
+ def visit_class_variable_or_write_node(node); end
+
+ # Copy a ClassVariableReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#159
+ def visit_class_variable_read_node(node); end
+
+ # Copy a ClassVariableTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#164
+ def visit_class_variable_target_node(node); end
+
+ # Copy a ClassVariableWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#169
+ def visit_class_variable_write_node(node); end
+
+ # Copy a ConstantAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#174
+ def visit_constant_and_write_node(node); end
+
+ # Copy a ConstantOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#179
+ def visit_constant_operator_write_node(node); end
+
+ # Copy a ConstantOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#184
+ def visit_constant_or_write_node(node); end
+
+ # Copy a ConstantPathAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#189
+ def visit_constant_path_and_write_node(node); end
+
+ # Copy a ConstantPathNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#194
+ def visit_constant_path_node(node); end
+
+ # Copy a ConstantPathOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#199
+ def visit_constant_path_operator_write_node(node); end
+
+ # Copy a ConstantPathOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#204
+ def visit_constant_path_or_write_node(node); end
+
+ # Copy a ConstantPathTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#209
+ def visit_constant_path_target_node(node); end
+
+ # Copy a ConstantPathWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#214
+ def visit_constant_path_write_node(node); end
+
+ # Copy a ConstantReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#219
+ def visit_constant_read_node(node); end
+
+ # Copy a ConstantTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#224
+ def visit_constant_target_node(node); end
+
+ # Copy a ConstantWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#229
+ def visit_constant_write_node(node); end
+
+ # Copy a DefNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#234
+ def visit_def_node(node); end
+
+ # Copy a DefinedNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#239
+ def visit_defined_node(node); end
+
+ # Copy a ElseNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#244
+ def visit_else_node(node); end
+
+ # Copy a EmbeddedStatementsNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#249
+ def visit_embedded_statements_node(node); end
+
+ # Copy a EmbeddedVariableNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#254
+ def visit_embedded_variable_node(node); end
+
+ # Copy a EnsureNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#259
+ def visit_ensure_node(node); end
+
+ # Copy a FalseNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#264
+ def visit_false_node(node); end
+
+ # Copy a FindPatternNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#269
+ def visit_find_pattern_node(node); end
+
+ # Copy a FlipFlopNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#274
+ def visit_flip_flop_node(node); end
+
+ # Copy a FloatNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#279
+ def visit_float_node(node); end
+
+ # Copy a ForNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#284
+ def visit_for_node(node); end
+
+ # Copy a ForwardingArgumentsNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#289
+ def visit_forwarding_arguments_node(node); end
+
+ # Copy a ForwardingParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#294
+ def visit_forwarding_parameter_node(node); end
+
+ # Copy a ForwardingSuperNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#299
+ def visit_forwarding_super_node(node); end
+
+ # Copy a GlobalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#304
+ def visit_global_variable_and_write_node(node); end
+
+ # Copy a GlobalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#309
+ def visit_global_variable_operator_write_node(node); end
+
+ # Copy a GlobalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#314
+ def visit_global_variable_or_write_node(node); end
+
+ # Copy a GlobalVariableReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#319
+ def visit_global_variable_read_node(node); end
+
+ # Copy a GlobalVariableTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#324
+ def visit_global_variable_target_node(node); end
+
+ # Copy a GlobalVariableWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#329
+ def visit_global_variable_write_node(node); end
+
+ # Copy a HashNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#334
+ def visit_hash_node(node); end
+
+ # Copy a HashPatternNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#339
+ def visit_hash_pattern_node(node); end
+
+ # Copy a IfNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#344
+ def visit_if_node(node); end
+
+ # Copy a ImaginaryNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#349
+ def visit_imaginary_node(node); end
+
+ # Copy a ImplicitNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#354
+ def visit_implicit_node(node); end
+
+ # Copy a ImplicitRestNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#359
+ def visit_implicit_rest_node(node); end
+
+ # Copy a InNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#364
+ def visit_in_node(node); end
+
+ # Copy a IndexAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#369
+ def visit_index_and_write_node(node); end
+
+ # Copy a IndexOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#374
+ def visit_index_operator_write_node(node); end
+
+ # Copy a IndexOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#379
+ def visit_index_or_write_node(node); end
+
+ # Copy a IndexTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#384
+ def visit_index_target_node(node); end
+
+ # Copy a InstanceVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#389
+ def visit_instance_variable_and_write_node(node); end
+
+ # Copy a InstanceVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#394
+ def visit_instance_variable_operator_write_node(node); end
+
+ # Copy a InstanceVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#399
+ def visit_instance_variable_or_write_node(node); end
+
+ # Copy a InstanceVariableReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#404
+ def visit_instance_variable_read_node(node); end
+
+ # Copy a InstanceVariableTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#409
+ def visit_instance_variable_target_node(node); end
+
+ # Copy a InstanceVariableWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#414
+ def visit_instance_variable_write_node(node); end
+
+ # Copy a IntegerNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#419
+ def visit_integer_node(node); end
+
+ # Copy a InterpolatedMatchLastLineNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#424
+ def visit_interpolated_match_last_line_node(node); end
+
+ # Copy a InterpolatedRegularExpressionNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#429
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Copy a InterpolatedStringNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#434
+ def visit_interpolated_string_node(node); end
+
+ # Copy a InterpolatedSymbolNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#439
+ def visit_interpolated_symbol_node(node); end
+
+ # Copy a InterpolatedXStringNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#444
+ def visit_interpolated_x_string_node(node); end
+
+ # Copy a KeywordHashNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#449
+ def visit_keyword_hash_node(node); end
+
+ # Copy a KeywordRestParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#454
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Copy a LambdaNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#459
+ def visit_lambda_node(node); end
+
+ # Copy a LocalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#464
+ def visit_local_variable_and_write_node(node); end
+
+ # Copy a LocalVariableOperatorWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#469
+ def visit_local_variable_operator_write_node(node); end
+
+ # Copy a LocalVariableOrWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#474
+ def visit_local_variable_or_write_node(node); end
+
+ # Copy a LocalVariableReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#479
+ def visit_local_variable_read_node(node); end
+
+ # Copy a LocalVariableTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#484
+ def visit_local_variable_target_node(node); end
+
+ # Copy a LocalVariableWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#489
+ def visit_local_variable_write_node(node); end
+
+ # Copy a MatchLastLineNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#494
+ def visit_match_last_line_node(node); end
+
+ # Copy a MatchPredicateNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#499
+ def visit_match_predicate_node(node); end
+
+ # Copy a MatchRequiredNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#504
+ def visit_match_required_node(node); end
+
+ # Copy a MatchWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#509
+ def visit_match_write_node(node); end
+
+ # Copy a MissingNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#514
+ def visit_missing_node(node); end
+
+ # Copy a ModuleNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#519
+ def visit_module_node(node); end
+
+ # Copy a MultiTargetNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#524
+ def visit_multi_target_node(node); end
+
+ # Copy a MultiWriteNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#529
+ def visit_multi_write_node(node); end
+
+ # Copy a NextNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#534
+ def visit_next_node(node); end
+
+ # Copy a NilNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#539
+ def visit_nil_node(node); end
+
+ # Copy a NoKeywordsParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#544
+ def visit_no_keywords_parameter_node(node); end
+
+ # Copy a NumberedParametersNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#549
+ def visit_numbered_parameters_node(node); end
+
+ # Copy a NumberedReferenceReadNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#554
+ def visit_numbered_reference_read_node(node); end
+
+ # Copy a OptionalKeywordParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#559
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Copy a OptionalParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#564
+ def visit_optional_parameter_node(node); end
+
+ # Copy a OrNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#569
+ def visit_or_node(node); end
+
+ # Copy a ParametersNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#574
+ def visit_parameters_node(node); end
+
+ # Copy a ParenthesesNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#579
+ def visit_parentheses_node(node); end
+
+ # Copy a PinnedExpressionNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#584
+ def visit_pinned_expression_node(node); end
+
+ # Copy a PinnedVariableNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#589
+ def visit_pinned_variable_node(node); end
+
+ # Copy a PostExecutionNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#594
+ def visit_post_execution_node(node); end
+
+ # Copy a PreExecutionNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#599
+ def visit_pre_execution_node(node); end
+
+ # Copy a ProgramNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#604
+ def visit_program_node(node); end
+
+ # Copy a RangeNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#609
+ def visit_range_node(node); end
+
+ # Copy a RationalNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#614
+ def visit_rational_node(node); end
+
+ # Copy a RedoNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#619
+ def visit_redo_node(node); end
+
+ # Copy a RegularExpressionNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#624
+ def visit_regular_expression_node(node); end
+
+ # Copy a RequiredKeywordParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#629
+ def visit_required_keyword_parameter_node(node); end
+
+ # Copy a RequiredParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#634
+ def visit_required_parameter_node(node); end
+
+ # Copy a RescueModifierNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#639
+ def visit_rescue_modifier_node(node); end
+
+ # Copy a RescueNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#644
+ def visit_rescue_node(node); end
+
+ # Copy a RestParameterNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#649
+ def visit_rest_parameter_node(node); end
+
+ # Copy a RetryNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#654
+ def visit_retry_node(node); end
+
+ # Copy a ReturnNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#659
+ def visit_return_node(node); end
+
+ # Copy a SelfNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#664
+ def visit_self_node(node); end
+
+ # Copy a SingletonClassNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#669
+ def visit_singleton_class_node(node); end
+
+ # Copy a SourceEncodingNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#674
+ def visit_source_encoding_node(node); end
+
+ # Copy a SourceFileNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#679
+ def visit_source_file_node(node); end
+
+ # Copy a SourceLineNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#684
+ def visit_source_line_node(node); end
+
+ # Copy a SplatNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#689
+ def visit_splat_node(node); end
+
+ # Copy a StatementsNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#694
+ def visit_statements_node(node); end
+
+ # Copy a StringNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#699
+ def visit_string_node(node); end
+
+ # Copy a SuperNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#704
+ def visit_super_node(node); end
+
+ # Copy a SymbolNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#709
+ def visit_symbol_node(node); end
+
+ # Copy a TrueNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#714
+ def visit_true_node(node); end
+
+ # Copy a UndefNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#719
+ def visit_undef_node(node); end
+
+ # Copy a UnlessNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#724
+ def visit_unless_node(node); end
+
+ # Copy a UntilNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#729
+ def visit_until_node(node); end
+
+ # Copy a WhenNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#734
+ def visit_when_node(node); end
+
+ # Copy a WhileNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#739
+ def visit_while_node(node); end
+
+ # Copy a XStringNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#744
+ def visit_x_string_node(node); end
+
+ # Copy a YieldNode node
+ #
+ # source://prism//lib/prism/mutation_compiler.rb#749
+ def visit_yield_node(node); end
+end
+
+# Represents the use of the `next` keyword.
+#
+# next 1
+# ^^^^^^
+#
+# source://prism//lib/prism/node.rb#12387
+class Prism::NextNode < ::Prism::Node
+ # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [NextNode] a new instance of NextNode
+ #
+ # source://prism//lib/prism/node.rb#12395
+ sig do
+ params(
+ arguments: T.nilable(Prism::ArgumentsNode),
+ keyword_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(arguments, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12402
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#12389
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12407
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12419
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12412
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> NextNode
+ #
+ # source://prism//lib/prism/node.rb#12424
+ sig { params(params: T.untyped).returns(Prism::NextNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12407
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12436
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12446
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12441
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12392
+ 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#12472
+ 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#12482
+ def type; end
+ end
+end
+
+# Represents the use of the `nil` keyword.
+#
+# nil
+# ^^^
+#
+# source://prism//lib/prism/node.rb#12491
+class Prism::NilNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [NilNode] a new instance of NilNode
+ #
+ # source://prism//lib/prism/node.rb#12493
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12498
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12503
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12513
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12508
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> NilNode
+ #
+ # source://prism//lib/prism/node.rb#12518
+ sig { params(params: T.untyped).returns(Prism::NilNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12503
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12528
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12533
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#12552
+ 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#12562
+ def type; end
+ end
+end
+
+# Represents the use of `**nil` inside method arguments.
+#
+# def a(**nil)
+# ^^^^^
+# end
+#
+# source://prism//lib/prism/node.rb#12572
+class Prism::NoKeywordsParameterNode < ::Prism::Node
+ # def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void
+ #
+ # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12580
+ sig { params(operator_loc: Prism::Location, keyword_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(operator_loc, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12587
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12592
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12602
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12597
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> NoKeywordsParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12607
+ sig { params(params: T.untyped).returns(Prism::NoKeywordsParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12592
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12619
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12634
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12629
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12577
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#12624
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12574
+ 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#12655
+ 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#12665
+ 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#11
+class Prism::Node
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # A Location instance that represents the location of this node in the
+ # source.
+ #
+ # source://prism//lib/prism/node.rb#14
+ sig { returns(Prism::Location) }
+ def location; end
+
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16
+ def newline?; end
+
+ # Similar to inspect, but respects the current level of indentation given by
+ # the pretty print object.
+ #
+ # source://prism//lib/prism/node.rb#35
+ def pretty_print(q); end
+
+ # source://prism//lib/prism/node.rb#20
+ def set_newline_flag(newline_marked); end
+
+ # Slice the location of the node from the source.
+ #
+ # source://prism//lib/prism/node.rb#29
+ sig { returns(String) }
+ def slice; end
+
+ # Convert this node into a graphviz dot graph string.
+ #
+ # source://prism//lib/prism/node.rb#43
+ sig { returns(String) }
+ def to_dot; end
+end
+
+# This object is responsible for generating the output for the inspect method
+# implementations of child nodes.
+#
+# source://prism//lib/prism/node_inspector.rb#6
+class Prism::NodeInspector
+ # @return [NodeInspector] a new instance of NodeInspector
+ #
+ # source://prism//lib/prism/node_inspector.rb#9
+ def initialize(prefix = T.unsafe(nil)); end
+
+ # Appends a line to the output with the current prefix.
+ #
+ # source://prism//lib/prism/node_inspector.rb#15
+ sig { params(line: String).void }
+ def <<(line); end
+
+ # Returns a new inspector that can be used to inspect a child node.
+ #
+ # source://prism//lib/prism/node_inspector.rb#59
+ sig { params(append: String).returns(Prism::NodeInspector) }
+ def child_inspector(append); end
+
+ # Generates a string that represents a child node.
+ #
+ # source://prism//lib/prism/node_inspector.rb#54
+ sig { params(node: Prism::Node, append: String).returns(String) }
+ def child_node(node, append); end
+
+ # This generates a string that is used as the header of the inspect output
+ # for any given node.
+ #
+ # source://prism//lib/prism/node_inspector.rb#21
+ # This generates a string that is used as the header of the inspect output
+ sig { params(node: Prism::Node).returns(String) }
+ def header(node); end
+
+ # Generates a string that represents a list of nodes. It handles properly
+ # using the box drawing characters to make the output look nice.
+ #
+ # source://prism//lib/prism/node_inspector.rb#31
+ # Generates a string that represents a list of nodes. It handles properly
+ sig { params(prefix: String, nodes: T::Array[Prism::Node]).returns(String) }
+ def list(prefix, nodes); end
+
+ # Generates a string that represents a location field on a node.
+ #
+ # source://prism//lib/prism/node_inspector.rb#45
+ sig { params(value: Prism::Location).returns(String) }
+ def location(value); end
+
+ # source://prism//lib/prism/node_inspector.rb#7
+ sig { returns(String) }
+ def output; end
+
+ # source://prism//lib/prism/node_inspector.rb#7
+ sig { returns(String) }
+ def prefix; end
+
+ # Returns the output as a string.
+ #
+ # source://prism//lib/prism/node_inspector.rb#64
+ sig { returns(String) }
+ def to_str; end
+end
+
+# Represents an implicit set of parameters through the use of numbered
+# parameters within a block or lambda.
+#
+# -> { _1 + _2 }
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#12675
+class Prism::NumberedParametersNode < ::Prism::Node
+ # def initialize: (maximum: Integer, location: Location) -> void
+ #
+ # @return [NumberedParametersNode] a new instance of NumberedParametersNode
+ #
+ # source://prism//lib/prism/node.rb#12680
+ sig { params(maximum: Integer, location: Prism::Location).void }
+ def initialize(maximum, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12686
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12691
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12701
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12696
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> NumberedParametersNode
+ #
+ # source://prism//lib/prism/node.rb#12706
+ sig { params(params: T.untyped).returns(Prism::NumberedParametersNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12691
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12717
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12722
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader maximum: Integer
+ #
+ # source://prism//lib/prism/node.rb#12677
+ 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#12742
+ 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#12752
+ def type; end
+ end
+end
+
+# Represents reading a numbered reference to a capture in the previous match.
+#
+# $1
+# ^^
+#
+# source://prism//lib/prism/node.rb#12761
+class Prism::NumberedReferenceReadNode < ::Prism::Node
+ # def initialize: (number: Integer, location: Location) -> void
+ #
+ # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
+ #
+ # source://prism//lib/prism/node.rb#12766
+ sig { params(number: Integer, location: Prism::Location).void }
+ def initialize(number, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12772
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12777
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12787
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12782
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> NumberedReferenceReadNode
+ #
+ # source://prism//lib/prism/node.rb#12792
+ sig { params(params: T.untyped).returns(Prism::NumberedReferenceReadNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12777
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12803
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12808
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader number: Integer
+ #
+ # source://prism//lib/prism/node.rb#12763
+ 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#12828
+ 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#12838
+ 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#12848
+class Prism::OptionalKeywordParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12859
+ sig { params(name: Symbol, name_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+ def initialize(name, name_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12867
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12872
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12882
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12877
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> OptionalKeywordParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12887
+ sig { params(params: T.untyped).returns(Prism::OptionalKeywordParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12872
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#12900
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#12905
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#12850
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12853
+ sig { returns(Prism::Location) }
+ def name_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#12928
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#12856
+ 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#12938
+ 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#12948
+class Prism::OptionalParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+ #
+ # @return [OptionalParameterNode] a new instance of OptionalParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12962
+ sig do
+ params(
+ name: Symbol,
+ name_loc: Prism::Location,
+ operator_loc: Prism::Location,
+ value: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, value, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#12971
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12976
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#12986
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#12981
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> OptionalParameterNode
+ #
+ # source://prism//lib/prism/node.rb#12991
+ sig { params(params: T.untyped).returns(Prism::OptionalParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#12976
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13005
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13015
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#12950
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12953
+ sig { returns(Prism::Location) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13010
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#12956
+ 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#13039
+ def type; end
+
+ # attr_reader value: Node
+ #
+ # source://prism//lib/prism/node.rb#12959
+ 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 the use of the `||` operator or the `or` keyword.
+#
+# left or right
+# ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13058
+class Prism::OrNode < ::Prism::Node
+ # def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [OrNode] a new instance of OrNode
+ #
+ # source://prism//lib/prism/node.rb#13069
+ sig { params(left: Prism::Node, right: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(left, right, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13077
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13082
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13092
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13087
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> OrNode
+ #
+ # source://prism//lib/prism/node.rb#13097
+ sig { params(params: T.untyped).returns(Prism::OrNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13082
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13110
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13120
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node
+ #
+ # source://prism//lib/prism/node.rb#13060
+ sig { returns(Prism::Node) }
+ def left; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13115
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13066
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader right: Node
+ #
+ # source://prism//lib/prism/node.rb#13063
+ 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#13144
+ 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#13154
+ def type; end
+ end
+end
+
+# A parser for the pack template language.
+#
+# source://prism//lib/prism/pack.rb#5
+module Prism::Pack
+ class << self
+ def parse(_arg0, _arg1, _arg2); end
+ end
+end
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
+
+# A directive in the pack template language.
+#
+# source://prism//lib/prism/pack.rb#59
+class Prism::Pack::Directive
+ # Initialize a new directive with the given values.
+ #
+ # @return [Directive] a new instance of Directive
+ #
+ # source://prism//lib/prism/pack.rb#88
+ def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
+
+ # Provide a human-readable description of the directive.
+ #
+ # source://prism//lib/prism/pack.rb#130
+ def describe; end
+
+ # The type of endianness of the directive.
+ #
+ # source://prism//lib/prism/pack.rb#76
+ def endian; end
+
+ # The length of this directive (used for integers).
+ #
+ # source://prism//lib/prism/pack.rb#85
+ def length; end
+
+ # The length type of this directive (used for integers).
+ #
+ # source://prism//lib/prism/pack.rb#82
+ def length_type; end
+
+ # The type of signedness of the directive.
+ #
+ # source://prism//lib/prism/pack.rb#73
+ def signed; end
+
+ # The size of the directive.
+ #
+ # source://prism//lib/prism/pack.rb#79
+ def size; end
+
+ # A byteslice of the source string that this directive represents.
+ #
+ # source://prism//lib/prism/pack.rb#67
+ def source; end
+
+ # The type of the directive.
+ #
+ # source://prism//lib/prism/pack.rb#70
+ def type; end
+
+ # A symbol representing whether or not we are packing or unpacking.
+ #
+ # source://prism//lib/prism/pack.rb#64
+ def variant; end
+
+ # A symbol representing the version of Ruby.
+ #
+ # source://prism//lib/prism/pack.rb#61
+ def version; end
+end
+
+# The descriptions of the various types of endianness.
+#
+# source://prism//lib/prism/pack.rb#101
+Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of signedness.
+#
+# source://prism//lib/prism/pack.rb#110
+Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# The descriptions of the various types of sizes.
+#
+# source://prism//lib/prism/pack.rb#117
+Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
+
+# The result of parsing a pack template.
+#
+# source://prism//lib/prism/pack.rb#195
+class Prism::Pack::Format
+ # Create a new Format with the given directives and encoding.
+ #
+ # @return [Format] a new instance of Format
+ #
+ # source://prism//lib/prism/pack.rb#203
+ def initialize(directives, encoding); end
+
+ # Provide a human-readable description of the format.
+ #
+ # source://prism//lib/prism/pack.rb#209
+ def describe; end
+
+ # A list of the directives in the template.
+ #
+ # source://prism//lib/prism/pack.rb#197
+ def directives; end
+
+ # The encoding of the template.
+ #
+ # source://prism//lib/prism/pack.rb#200
+ def encoding; end
+end
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
+
+# source://prism//lib/prism/pack.rb#55
+Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
+
+# Represents the list of parameters on a method, block, or lambda definition.
+#
+# def a(b, c, d)
+# ^^^^^^^
+# end
+#
+# source://prism//lib/prism/node.rb#13164
+class Prism::ParametersNode < ::Prism::Node
+ # def initialize: (requireds: Array[Node], optionals: Array[Node], rest: Node?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
+ #
+ # @return [ParametersNode] a new instance of ParametersNode
+ #
+ # source://prism//lib/prism/node.rb#13187
+ sig do
+ params(
+ requireds: T::Array[Prism::Node],
+ optionals: T::Array[Prism::Node],
+ rest: T.nilable(Prism::Node),
+ posts: T::Array[Prism::Node],
+ keywords: T::Array[Prism::Node],
+ keyword_rest: T.nilable(Prism::Node),
+ block: T.nilable(Prism::BlockParameterNode),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13199
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader block: BlockParameterNode?
+ #
+ # source://prism//lib/prism/node.rb#13184
+ sig { returns(T.nilable(Prism::BlockParameterNode)) }
+ def block; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13204
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13222
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13209
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ParametersNode
+ #
+ # source://prism//lib/prism/node.rb#13227
+ sig { params(params: T.untyped).returns(Prism::ParametersNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13204
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13244
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13249
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader keyword_rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#13181
+ sig { returns(T.nilable(Prism::Node)) }
+ def keyword_rest; end
+
+ # attr_reader keywords: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13178
+ sig { returns(T::Array[Prism::Node]) }
+ def keywords; end
+
+ # attr_reader optionals: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13169
+ sig { returns(T::Array[Prism::Node]) }
+ def optionals; end
+
+ # attr_reader posts: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13175
+ sig { returns(T::Array[Prism::Node]) }
+ def posts; end
+
+ # attr_reader requireds: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13166
+ sig { returns(T::Array[Prism::Node]) }
+ def requireds; end
+
+ # attr_reader rest: Node?
+ #
+ # source://prism//lib/prism/node.rb#13172
+ sig { returns(T.nilable(Prism::Node)) }
+ def rest; end
+
+ # Mirrors the Method#parameters method.
+ #
+ # source://prism//lib/prism/node_ext.rb#149
+ def signature; end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#13290
+ 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#13300
+ def type; end
+ end
+end
+
+# Represents a parenthesized expression
+#
+# (10 + 34)
+# ^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13309
+class Prism::ParenthesesNode < ::Prism::Node
+ # def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+ #
+ # @return [ParenthesesNode] a new instance of ParenthesesNode
+ #
+ # source://prism//lib/prism/node.rb#13320
+ sig do
+ params(
+ body: T.nilable(Prism::Node),
+ opening_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(body, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13328
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#13311
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13337
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13377
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13317
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13349
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13342
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ParenthesesNode
+ #
+ # source://prism//lib/prism/node.rb#13354
+ sig { params(params: T.untyped).returns(Prism::ParenthesesNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13337
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13367
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13382
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13372
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13314
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # source://prism//lib/prism/node.rb#13332
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#13409
+ 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#13419
+ def type; end
+ end
+end
+
+# This represents an error that was encountered during parsing.
+#
+# source://prism//lib/prism/parse_result.rb#308
+class Prism::ParseError
+ # Create a new error object with the given message and location.
+ #
+ # @return [ParseError] a new instance of ParseError
+ #
+ # source://prism//lib/prism/parse_result.rb#316
+ def initialize(message, location); end
+
+ # Implement the hash pattern matching interface for ParseError.
+ #
+ # source://prism//lib/prism/parse_result.rb#322
+ def deconstruct_keys(keys); end
+
+ # Returns a string representation of this error.
+ #
+ # source://prism//lib/prism/parse_result.rb#327
+ def inspect; end
+
+ # A Location object representing the location of this error in the source.
+ #
+ # source://prism//lib/prism/parse_result.rb#313
+ sig { returns(Prism::Location) }
+ def location; end
+
+ # The message associated with this error.
+ #
+ # source://prism//lib/prism/parse_result.rb#310
+ sig { returns(String) }
+ def message; end
+end
+
+# This represents the result of a call to ::parse or ::parse_file. It contains
+# the AST, any comments that were encounters, and any errors that were
+# encountered.
+#
+# source://prism//lib/prism/parse_result.rb#360
+class Prism::ParseResult
+ # Create a new parse result object with the given values.
+ #
+ # @return [ParseResult] a new instance of ParseResult
+ #
+ # source://prism//lib/prism/parse_result.rb#387
+ 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/comments.rb#173
+ def attach_comments!; end
+
+ # The list of comments that were encountered during parsing.
+ #
+ # source://prism//lib/prism/parse_result.rb#367
+ sig { returns(T::Array[Prism::Comment]) }
+ def comments; end
+
+ # An optional location that represents the location of the content after the
+ # __END__ marker. 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#375
+ def data_loc; end
+
+ # Implement the hash pattern matching interface for ParseResult.
+ #
+ # source://prism//lib/prism/parse_result.rb#398
+ def deconstruct_keys(keys); end
+
+ # The list of errors that were generated during parsing.
+ #
+ # source://prism//lib/prism/parse_result.rb#378
+ 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#410
+ def failure?; end
+
+ # The list of magic comments that were encountered during parsing.
+ #
+ # source://prism//lib/prism/parse_result.rb#370
+ def magic_comments; end
+
+ # Walk the tree and mark nodes that are on a new line.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#60
+ def mark_newlines!; end
+
+ # A Source instance that represents the source code that was parsed.
+ #
+ # source://prism//lib/prism/parse_result.rb#384
+ 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#404
+ def success?; end
+
+ # The value that was generated by parsing. Normally this holds the AST, but
+ # it can sometimes how a list of tokens or other results passed back from
+ # the parser.
+ #
+ # source://prism//lib/prism/parse_result.rb#364
+ sig { returns(Prism::ProgramNode) }
+ def value; end
+
+ # The list of warnings that were generated during parsing.
+ #
+ # source://prism//lib/prism/parse_result.rb#381
+ sig { returns(T::Array[Prism::ParseWarning]) }
+ def warnings; end
+end
+
+# When we've parsed the source, we have both the syntax tree and the list of
+# comments that we found in the source. This class is responsible for
+# walking the tree and finding the nearest location to attach each comment.
+#
+# It does this by first finding the nearest locations to each comment.
+# Locations can either come from nodes directly or from location fields on
+# nodes. For example, a `ClassNode` has an overall location encompassing the
+# entire class, but it also has a location for the `class` keyword.
+#
+# Once the nearest locations are found, it determines which one to attach
+# to. If it's a trailing comment (a comment on the same line as other source
+# code), it will favor attaching to the nearest location that occurs before
+# the comment. Otherwise it will favor attaching to the nearest location
+# that is after the comment.
+#
+# source://prism//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#78
+ 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#84
+ def attach!; end
+
+ # The parse result that we are attaching comments to.
+ #
+ # source://prism//lib/prism/parse_result/comments.rb#74
+ def parse_result; end
+
+ private
+
+ # Responsible for finding the nearest targets to the given comment within
+ # the context of the given encapsulating node.
+ #
+ # source://prism//lib/prism/parse_result/comments.rb#103
+ def nearest_targets(node, comment); end
+end
+
+# A target for attaching comments that is based on a location field on a
+# node. For example, the `end` token of a ClassNode.
+#
+# source://prism//lib/prism/parse_result/comments.rb#49
+class Prism::ParseResult::Comments::LocationTarget
+ # @return [LocationTarget] a new instance of LocationTarget
+ #
+ # source://prism//lib/prism/parse_result/comments.rb#52
+ def initialize(location); end
+
+ # source://prism//lib/prism/parse_result/comments.rb#68
+ def <<(comment); end
+
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/parse_result/comments.rb#64
+ def encloses?(comment); end
+
+ # source://prism//lib/prism/parse_result/comments.rb#60
+ def end_offset; end
+
+ # source://prism//lib/prism/parse_result/comments.rb#50
+ def location; end
+
+ # source://prism//lib/prism/parse_result/comments.rb#56
+ def start_offset; end
+end
+
+# A target for attaching comments that is based on a specific node's
+# location.
+#
+# source://prism//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
+
+ # source://prism//lib/prism/parse_result/comments.rb#42
+ def <<(comment); 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#23
+ def node; end
+
+ # source://prism//lib/prism/parse_result/comments.rb#29
+ def start_offset; end
+end
+
+# The :line tracepoint event gets fired whenever the Ruby VM encounters an
+# expression on a new line. The types of expressions that can trigger this
+# event are:
+#
+# * if statements
+# * unless statements
+# * nodes that are children of statements lists
+#
+# In order to keep track of the newlines, we have a list of offsets that
+# come back from the parser. We assign these offsets to the first nodes that
+# we find in the tree that are on those lines.
+#
+# Note that the logic in this file should be kept in sync with the Java
+# MarkNewlinesVisitor, since that visitor is responsible for marking the
+# newlines for JRuby/TruffleRuby.
+#
+# source://prism//lib/prism/parse_result/newlines.rb#20
+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#22
+ def initialize(newline_marked); end
+
+ # Permit block/lambda nodes to mark newlines within themselves.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#27
+ def visit_block_node(node); end
+
+ # Mark if/unless nodes as newlines.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#41
+ def visit_if_node(node); end
+
+ # Permit block/lambda nodes to mark newlines within themselves.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#27
+ def visit_lambda_node(node); end
+
+ # Permit statements lists to mark newlines within themselves.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#49
+ def visit_statements_node(node); end
+
+ # Mark if/unless nodes as newlines.
+ #
+ # source://prism//lib/prism/parse_result/newlines.rb#41
+ def visit_unless_node(node); end
+end
+
+# This represents a warning that was encountered during parsing.
+#
+# source://prism//lib/prism/parse_result.rb#333
+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#341
+ def initialize(message, location); end
+
+ # Implement the hash pattern matching interface for ParseWarning.
+ #
+ # source://prism//lib/prism/parse_result.rb#347
+ def deconstruct_keys(keys); end
+
+ # Returns a string representation of this warning.
+ #
+ # source://prism//lib/prism/parse_result.rb#352
+ def inspect; end
+
+ # A Location object representing the location of this warning in the source.
+ #
+ # source://prism//lib/prism/parse_result.rb#338
+ sig { returns(Prism::Location) }
+ def location; end
+
+ # The message associated with this warning.
+ #
+ # source://prism//lib/prism/parse_result.rb#335
+ sig { returns(String) }
+ def message; end
+end
+
+# A pattern is an object that wraps a Ruby pattern matching expression. The
+# expression would normally be passed to an `in` clause within a `case`
+# expression or a rightward assignment expression. For example, in the
+# following snippet:
+#
+# case node
+# in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
+# end
+#
+# the pattern is the ConstantPathNode[...] 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.
+ #
+ # 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#79
+ 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#95
+ 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#101
+ def combine_or(left, right); end
+
+ # in foo | bar
+ #
+ # source://prism//lib/prism/pattern.rb#136
+ def compile_alternation_pattern_node(node); end
+
+ # in [foo, bar, baz]
+ #
+ # source://prism//lib/prism/pattern.rb#111
+ def compile_array_pattern_node(node); end
+
+ # in Prism::ConstantReadNode
+ #
+ # source://prism//lib/prism/pattern.rb#141
+ def compile_constant_path_node(node); end
+
+ # in ConstantReadNode
+ # in String
+ #
+ # source://prism//lib/prism/pattern.rb#153
+ def compile_constant_read_node(node); end
+
+ # Raise an error because the given node is not supported.
+ #
+ # @raise [CompilationError]
+ #
+ # source://prism//lib/prism/pattern.rb#106
+ def compile_error(node); end
+
+ # in InstanceVariableReadNode[name: Symbol]
+ # in { name: Symbol }
+ #
+ # source://prism//lib/prism/pattern.rb#171
+ def compile_hash_pattern_node(node); end
+
+ # in nil
+ #
+ # source://prism//lib/prism/pattern.rb#196
+ def compile_nil_node(node); end
+
+ # Compile any kind of node. Dispatch out to the individual compilation
+ # methods based on the type of node.
+ #
+ # source://prism//lib/prism/pattern.rb#225
+ def compile_node(node); end
+
+ # in /foo/
+ #
+ # source://prism//lib/prism/pattern.rb#201
+ def compile_regular_expression_node(node); end
+
+ # in ""
+ # in "foo"
+ #
+ # source://prism//lib/prism/pattern.rb#209
+ def compile_string_node(node); end
+
+ # in :+
+ # in :foo
+ #
+ # source://prism//lib/prism/pattern.rb#217
+ def compile_symbol_node(node); end
+end
+
+# Raised when the query given to a pattern is either invalid Ruby syntax or
+# is using syntax that we don't yet support.
+#
+# source://prism//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#13429
+class Prism::PinnedExpressionNode < ::Prism::Node
+ # def initialize: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> void
+ #
+ # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#13443
+ sig do
+ params(
+ expression: Prism::Node,
+ operator_loc: Prism::Location,
+ lparen_loc: Prism::Location,
+ rparen_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(expression, operator_loc, lparen_loc, rparen_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13452
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13457
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13467
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13462
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> PinnedExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#13472
+ sig { params(params: T.untyped).returns(Prism::PinnedExpressionNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13457
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13486
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader expression: Node
+ #
+ # source://prism//lib/prism/node.rb#13431
+ sig { returns(Prism::Node) }
+ def expression; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13506
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def lparen: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13496
+ sig { returns(String) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13437
+ sig { returns(Prism::Location) }
+ def lparen_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13491
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13434
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # def rparen: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13501
+ sig { returns(String) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13440
+ 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#13530
+ 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#13540
+ 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#13550
+class Prism::PinnedVariableNode < ::Prism::Node
+ # def initialize: (variable: Node, operator_loc: Location, location: Location) -> void
+ #
+ # @return [PinnedVariableNode] a new instance of PinnedVariableNode
+ #
+ # source://prism//lib/prism/node.rb#13558
+ sig { params(variable: Prism::Node, operator_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(variable, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13565
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13570
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13580
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13575
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> PinnedVariableNode
+ #
+ # source://prism//lib/prism/node.rb#13585
+ sig { params(params: T.untyped).returns(Prism::PinnedVariableNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13570
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13597
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13607
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13602
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13555
+ 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#13629
+ def type; end
+
+ # attr_reader variable: Node
+ #
+ # source://prism//lib/prism/node.rb#13552
+ 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#13639
+ def type; end
+ end
+end
+
+# Represents the use of the `END` keyword.
+#
+# END { foo }
+# ^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13648
+class Prism::PostExecutionNode < ::Prism::Node
+ # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+ #
+ # @return [PostExecutionNode] a new instance of PostExecutionNode
+ #
+ # source://prism//lib/prism/node.rb#13662
+ sig do
+ params(
+ statements: T.nilable(Prism::StatementsNode),
+ keyword_loc: Prism::Location,
+ opening_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13671
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13676
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13722
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13659
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13688
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13681
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> PostExecutionNode
+ #
+ # source://prism//lib/prism/node.rb#13693
+ sig { params(params: T.untyped).returns(Prism::PostExecutionNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13676
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13707
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13727
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13712
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13653
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13717
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13656
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#13650
+ 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#13755
+ 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#13765
+ def type; end
+ end
+end
+
+# Represents the use of the `BEGIN` keyword.
+#
+# BEGIN { foo }
+# ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#13774
+class Prism::PreExecutionNode < ::Prism::Node
+ # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+ #
+ # @return [PreExecutionNode] a new instance of PreExecutionNode
+ #
+ # source://prism//lib/prism/node.rb#13788
+ sig do
+ params(
+ statements: T.nilable(Prism::StatementsNode),
+ keyword_loc: Prism::Location,
+ opening_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(statements, keyword_loc, opening_loc, closing_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13797
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13802
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13848
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13785
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13814
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13807
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> PreExecutionNode
+ #
+ # source://prism//lib/prism/node.rb#13819
+ sig { params(params: T.untyped).returns(Prism::PreExecutionNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13802
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13833
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13853
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13838
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13779
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#13843
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#13782
+ sig { returns(Prism::Location) }
+ def opening_loc; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#13776
+ 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#13881
+ 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#13891
+ def type; end
+ end
+end
+
+# The top level node of any parse tree.
+#
+# source://prism//lib/prism/node.rb#13897
+class Prism::ProgramNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void
+ #
+ # @return [ProgramNode] a new instance of ProgramNode
+ #
+ # source://prism//lib/prism/node.rb#13905
+ sig { params(locals: T::Array[Symbol], statements: Prism::StatementsNode, location: Prism::Location).void }
+ def initialize(locals, statements, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#13912
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13917
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#13927
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#13922
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ProgramNode
+ #
+ # source://prism//lib/prism/node.rb#13932
+ sig { params(params: T.untyped).returns(Prism::ProgramNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#13917
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#13944
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#13949
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#13899
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # attr_reader statements: StatementsNode
+ #
+ # source://prism//lib/prism/node.rb#13902
+ 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#13971
+ 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#13981
+ def type; end
+ end
+end
+
+# Flags for range and flip-flop nodes.
+#
+# source://prism//lib/prism/node.rb#17337
+module Prism::RangeFlags; end
+
+# ... operator
+#
+# source://prism//lib/prism/node.rb#17339
+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#13993
+class Prism::RangeNode < ::Prism::Node
+ # def initialize: (flags: Integer, left: Node?, right: Node?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [RangeNode] a new instance of RangeNode
+ #
+ # source://prism//lib/prism/node.rb#14007
+ sig do
+ params(
+ flags: Integer,
+ left: T.nilable(Prism::Node),
+ right: T.nilable(Prism::Node),
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, left, right, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14016
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14021
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14034
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14026
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RangeNode
+ #
+ # source://prism//lib/prism/node.rb#14039
+ sig { params(params: T.untyped).returns(Prism::RangeNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14021
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14053
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def exclude_end?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14058
+ sig { returns(T::Boolean) }
+ def exclude_end?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14068
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader left: Node?
+ #
+ # source://prism//lib/prism/node.rb#13998
+ sig { returns(T.nilable(Prism::Node)) }
+ def left; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14063
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14004
+ sig { returns(Prism::Location) }
+ def operator_loc; end
+
+ # attr_reader right: Node?
+ #
+ # source://prism//lib/prism/node.rb#14001
+ 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#14102
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#13995
+ 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#14112
+ def type; end
+ end
+end
+
+# Represents a rational number literal.
+#
+# 1.0r
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#14121
+class Prism::RationalNode < ::Prism::Node
+ # def initialize: (numeric: Node, location: Location) -> void
+ #
+ # @return [RationalNode] a new instance of RationalNode
+ #
+ # source://prism//lib/prism/node.rb#14126
+ sig { params(numeric: Prism::Node, location: Prism::Location).void }
+ def initialize(numeric, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14132
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14137
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14147
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14142
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RationalNode
+ #
+ # source://prism//lib/prism/node.rb#14152
+ sig { params(params: T.untyped).returns(Prism::RationalNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14137
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14163
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14168
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader numeric: Node
+ #
+ # source://prism//lib/prism/node.rb#14123
+ sig { returns(Prism::Node) }
+ def numeric; end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#14189
+ def type; end
+
+ # Returns the value of the node as a Ruby Rational.
+ #
+ # source://prism//lib/prism/node_ext.rb#83
+ def value; end
+
+ class << self
+ # Similar to #type, this method returns a symbol that you can use for
+ # splitting on the type of the node without having to do a long === chain.
+ # Note that like #type, it will still be slower than using == for a single
+ # class, but should be faster in a case statement or an array comparison.
+ #
+ # def self.type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#14199
+ def type; end
+ end
+end
+
+# Represents the use of the `redo` keyword.
+#
+# redo
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#14208
+class Prism::RedoNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [RedoNode] a new instance of RedoNode
+ #
+ # source://prism//lib/prism/node.rb#14210
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14215
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14220
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14230
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14225
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RedoNode
+ #
+ # source://prism//lib/prism/node.rb#14235
+ sig { params(params: T.untyped).returns(Prism::RedoNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14220
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14245
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14250
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#14269
+ 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#14279
+ def type; end
+ end
+end
+
+# Flags for regular expression and match last line nodes.
+#
+# source://prism//lib/prism/node.rb#17343
+module Prism::RegularExpressionFlags; end
+
+# n - forces the ASCII-8BIT encoding
+#
+# source://prism//lib/prism/node.rb#17360
+Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
+
+# e - forces the EUC-JP encoding
+#
+# source://prism//lib/prism/node.rb#17357
+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#17348
+Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#17372
+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#17375
+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#17369
+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#17345
+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#17351
+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#17354
+Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
+
+# u - forces the UTF-8 encoding
+#
+# source://prism//lib/prism/node.rb#17366
+Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
+
+# s - forces the Windows-31J encoding
+#
+# source://prism//lib/prism/node.rb#17363
+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#14288
+class Prism::RegularExpressionNode < ::Prism::Node
+ include ::Prism::RegularExpressionOptions
+
+ # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+ #
+ # @return [RegularExpressionNode] a new instance of RegularExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#14305
+ sig do
+ params(
+ flags: Integer,
+ opening_loc: Prism::Location,
+ content_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ unescaped: String,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14315
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def ascii_8bit?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14380
+ sig { returns(T::Boolean) }
+ def ascii_8bit?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14320
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14420
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14299
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14330
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14325
+ def compact_child_nodes; end
+
+ # def content: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14415
+ sig { returns(String) }
+ def content; end
+
+ # attr_reader content_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14296
+ sig { returns(Prism::Location) }
+ def content_loc; end
+
+ # def copy: (**params) -> RegularExpressionNode
+ #
+ # source://prism//lib/prism/node.rb#14335
+ sig { params(params: T.untyped).returns(Prism::RegularExpressionNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14320
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14350
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def euc_jp?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14375
+ sig { returns(T::Boolean) }
+ def euc_jp?; end
+
+ # def extended?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14360
+ sig { returns(T::Boolean) }
+ def extended?; end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14400
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_us_ascii_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14405
+ sig { returns(T::Boolean) }
+ def forced_us_ascii_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14395
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def ignore_case?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14355
+ sig { returns(T::Boolean) }
+ def ignore_case?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14425
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def multi_line?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14365
+ sig { returns(T::Boolean) }
+ def multi_line?; end
+
+ # def once?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14370
+ sig { returns(T::Boolean) }
+ def once?; end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14410
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14293
+ 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#14450
+ def type; end
+
+ # attr_reader unescaped: String
+ #
+ # source://prism//lib/prism/node.rb#14302
+ sig { returns(String) }
+ def unescaped; end
+
+ # def utf_8?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14390
+ sig { returns(T::Boolean) }
+ def utf_8?; end
+
+ # def windows_31j?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#14385
+ sig { returns(T::Boolean) }
+ def windows_31j?; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#14290
+ 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#14460
+ def type; end
+ end
+end
+
+# source://prism//lib/prism/node_ext.rb#6
+module Prism::RegularExpressionOptions
+ # Returns a numeric value that represents the flags that were used to create
+ # the regular expression.
+ #
+ # source://prism//lib/prism/node_ext.rb#9
+ def options; end
+end
+
+# Represents a required keyword parameter to a method, block, or lambda definition.
+#
+# def a(b: )
+# ^^
+# end
+#
+# source://prism//lib/prism/node.rb#14470
+class Prism::RequiredKeywordParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol, name_loc: Location, location: Location) -> void
+ #
+ # @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14478
+ sig { params(name: Symbol, name_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(name, name_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14485
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14490
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14500
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14495
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RequiredKeywordParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14505
+ sig { params(params: T.untyped).returns(Prism::RequiredKeywordParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14490
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14517
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14522
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#14472
+ sig { returns(Symbol) }
+ def name; end
+
+ # attr_reader name_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14475
+ sig { returns(Prism::Location) }
+ def name_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#14543
+ 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#14553
+ 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#14563
+class Prism::RequiredParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol, location: Location) -> void
+ #
+ # @return [RequiredParameterNode] a new instance of RequiredParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14568
+ sig { params(name: Symbol, location: Prism::Location).void }
+ def initialize(name, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14574
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14579
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14589
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14584
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RequiredParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14594
+ sig { params(params: T.untyped).returns(Prism::RequiredParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14579
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14605
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14610
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol
+ #
+ # source://prism//lib/prism/node.rb#14565
+ 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#14630
+ 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#14640
+ def type; end
+ end
+end
+
+# Represents an expression modified with a rescue.
+#
+# foo rescue nil
+# ^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#14649
+class Prism::RescueModifierNode < ::Prism::Node
+ # def initialize: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> void
+ #
+ # @return [RescueModifierNode] a new instance of RescueModifierNode
+ #
+ # source://prism//lib/prism/node.rb#14660
+ sig do
+ params(
+ expression: Prism::Node,
+ keyword_loc: Prism::Location,
+ rescue_expression: Prism::Node,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(expression, keyword_loc, rescue_expression, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14668
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14677
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14687
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14682
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RescueModifierNode
+ #
+ # source://prism//lib/prism/node.rb#14692
+ sig { params(params: T.untyped).returns(Prism::RescueModifierNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14677
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14705
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader expression: Node
+ #
+ # source://prism//lib/prism/node.rb#14651
+ sig { returns(Prism::Node) }
+ def expression; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14715
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14710
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14654
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader rescue_expression: Node
+ #
+ # source://prism//lib/prism/node.rb#14657
+ sig { returns(Prism::Node) }
+ def rescue_expression; end
+
+ # source://prism//lib/prism/node.rb#14672
+ def set_newline_flag(newline_marked); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#14739
+ 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#14749
+ 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#14764
+class Prism::RescueNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void
+ #
+ # @return [RescueNode] a new instance of RescueNode
+ #
+ # source://prism//lib/prism/node.rb#14784
+ 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
+ ).void
+ end
+ def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14795
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14800
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14815
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14805
+ def compact_child_nodes; end
+
+ # attr_reader consequent: RescueNode?
+ #
+ # source://prism//lib/prism/node.rb#14781
+ sig { returns(T.nilable(Prism::RescueNode)) }
+ def consequent; end
+
+ # def copy: (**params) -> RescueNode
+ #
+ # source://prism//lib/prism/node.rb#14820
+ sig { params(params: T.untyped).returns(Prism::RescueNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14800
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14836
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader exceptions: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14769
+ sig { returns(T::Array[Prism::Node]) }
+ def exceptions; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14851
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14841
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14766
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def operator: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#14846
+ sig { returns(T.nilable(String)) }
+ def operator; end
+
+ # attr_reader operator_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#14772
+ sig { returns(T.nilable(Prism::Location)) }
+ def operator_loc; end
+
+ # attr_reader reference: Node?
+ #
+ # source://prism//lib/prism/node.rb#14775
+ sig { returns(T.nilable(Prism::Node)) }
+ def reference; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#14778
+ 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#14891
+ 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#14901
+ 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#14911
+class Prism::RestParameterNode < ::Prism::Node
+ # def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+ #
+ # @return [RestParameterNode] a new instance of RestParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14922
+ sig do
+ params(
+ name: T.nilable(Symbol),
+ name_loc: T.nilable(Prism::Location),
+ operator_loc: Prism::Location,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(name, name_loc, operator_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#14930
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14935
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#14945
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#14940
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RestParameterNode
+ #
+ # source://prism//lib/prism/node.rb#14950
+ sig { params(params: T.untyped).returns(Prism::RestParameterNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#14935
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#14963
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#14973
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader name: Symbol?
+ #
+ # source://prism//lib/prism/node.rb#14913
+ sig { returns(T.nilable(Symbol)) }
+ def name; end
+
+ # attr_reader name_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#14916
+ sig { returns(T.nilable(Prism::Location)) }
+ def name_loc; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#14968
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#14919
+ 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#14999
+ 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#15009
+ def type; end
+ end
+end
+
+# Represents the use of the `retry` keyword.
+#
+# retry
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#15018
+class Prism::RetryNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [RetryNode] a new instance of RetryNode
+ #
+ # source://prism//lib/prism/node.rb#15020
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15025
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15030
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15040
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15035
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> RetryNode
+ #
+ # source://prism//lib/prism/node.rb#15045
+ sig { params(params: T.untyped).returns(Prism::RetryNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15030
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15055
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15060
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15079
+ 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#15089
+ def type; end
+ end
+end
+
+# Represents the use of the `return` keyword.
+#
+# return 1
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15098
+class Prism::ReturnNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void
+ #
+ # @return [ReturnNode] a new instance of ReturnNode
+ #
+ # source://prism//lib/prism/node.rb#15106
+ sig do
+ params(
+ keyword_loc: Prism::Location,
+ arguments: T.nilable(Prism::ArgumentsNode),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(keyword_loc, arguments, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15113
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#15103
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15118
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15130
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15123
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> ReturnNode
+ #
+ # source://prism//lib/prism/node.rb#15135
+ sig { params(params: T.untyped).returns(Prism::ReturnNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15118
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15147
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15157
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15152
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15100
+ 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#15183
+ 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#15193
+ def type; end
+ end
+end
+
+# Note: This integration is not finished, and therefore still has many
+# inconsistencies with Ripper. If you'd like to help out, pull requests would
+# be greatly appreciated!
+#
+# This class is meant to provide a compatibility layer between prism and
+# Ripper. It functions by parsing the entire tree first and then walking it
+# and executing each of the Ripper callbacks as it goes.
+#
+# This class is going to necessarily be slower than the native Ripper API. It
+# is meant as a stopgap until developers migrate to using prism. It is also
+# meant as a test harness for the prism parser.
+#
+# To use this class, you treat `Prism::RipperCompat` effectively as you would
+# treat the `Ripper` class.
+#
+# source://prism//lib/prism/ripper_compat.rb#20
+class Prism::RipperCompat < ::Prism::Visitor
+ # Create a new RipperCompat object with the given source.
+ #
+ # @return [RipperCompat] a new instance of RipperCompat
+ #
+ # source://prism//lib/prism/ripper_compat.rb#74
+ def initialize(source); end
+
+ # The current column number of the parser.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#71
+ def column; end
+
+ # True if the parser encountered an error during parsing.
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/ripper_compat.rb#86
+ def error?; end
+
+ # The current line number of the parser.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#68
+ def lineno; end
+
+ # Parse the source and return the result.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#91
+ def parse; end
+
+ # The source that is being parsed.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#65
+ def source; end
+
+ # Visit a CallNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#110
+ def visit_call_node(node); end
+
+ # Visit a FloatNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#123
+ def visit_float_node(node); end
+
+ # Visit a ImaginaryNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#129
+ def visit_imaginary_node(node); end
+
+ # Visit an IntegerNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#135
+ def visit_integer_node(node); end
+
+ # Visit a ProgramNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#155
+ def visit_program_node(node); end
+
+ # Visit a RationalNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#141
+ def visit_rational_node(node); end
+
+ # Visit a StatementsNode node.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#147
+ def visit_statements_node(node); end
+
+ private
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def _dispatch0; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def _dispatch1(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def _dispatch2(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def _dispatch3(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def _dispatch4(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#197
+ def _dispatch5(_, _, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#198
+ def _dispatch7(_, _, _, _, _, _, _); end
+
+ # This method is responsible for updating lineno and column information
+ # to reflect the current node.
+ #
+ # This method could be drastically improved with some caching on the start
+ # of every line, but for now it's good enough.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#182
+ def bounds(location); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_BEGIN(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_CHAR(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_END(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on___end__(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_alias(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_alias_error(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_aref(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_aref_field(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_arg_ambiguous(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_arg_paren(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_args_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_args_add_block(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_args_add_star(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_args_forward; end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_args_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_array(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def on_aryptn(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_assign(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_assign_error(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_assoc_new(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_assoc_splat(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_assoclist_from_args(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_backref(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_backtick(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_bare_assoc_hash(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_begin(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_binary(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_block_var(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_blockarg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def on_bodystmt(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_brace_block(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_break(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_call(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_case(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_class(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_class_name_error(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_comma(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_command(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def on_command_call(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_comment(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_const(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_const_path_field(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_const_path_ref(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_const_ref(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_cvar(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_def(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_defined(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#197
+ def on_defs(_, _, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_do_block(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_dot2(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_dot3(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_dyna_symbol(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_else(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_elsif(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embdoc(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embdoc_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embdoc_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embexpr_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embexpr_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_embvar(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_ensure(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_excessed_comma; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_fcall(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_field(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_float(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def on_fndptn(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_for(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_gvar(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_hash(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_heredoc_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_heredoc_dedent(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_heredoc_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_hshptn(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_ident(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_if(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_if_mod(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_ifop(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_ignored_nl(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_ignored_sp(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_imaginary(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_in(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_int(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_ivar(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_kw(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_kwrest_param(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_label(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_label_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_lambda(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_lbrace(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_lbracket(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_lparen(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_magic_comment(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_massign(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_method_add_arg(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_method_add_block(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_mlhs_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_mlhs_add_post(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_mlhs_add_star(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_mlhs_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_mlhs_paren(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_module(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_mrhs_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_mrhs_add_star(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_mrhs_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_mrhs_new_from_args(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_next(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_nl(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_nokw_param(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_op(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_opassign(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_operator_ambiguous(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_param_error(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#198
+ def on_params(_, _, _, _, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_paren(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_parse_error(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_period(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_program(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_qsymbols_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_qsymbols_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_qsymbols_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_qwords_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_qwords_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_qwords_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_rational(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_rbrace(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_rbracket(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_redo; end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_regexp_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_regexp_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_regexp_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_regexp_literal(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_regexp_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#196
+ def on_rescue(_, _, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_rescue_mod(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_rest_param(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_retry; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_return(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_return0; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_rparen(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_sclass(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_semicolon(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_sp(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_stmts_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_stmts_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_string_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_string_concat(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_string_content; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_string_dvar(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_string_embexpr(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_string_literal(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_super(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_symbeg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_symbol(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_symbol_literal(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_symbols_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_symbols_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_symbols_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_tlambda(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_tlambeg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_top_const_field(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_top_const_ref(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_tstring_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_tstring_content(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_tstring_end(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_unary(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_undef(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_unless(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_unless_mod(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_until(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_until_mod(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_var_alias(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_var_field(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_var_ref(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_vcall(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_void_stmt; end
+
+ # source://prism//lib/prism/ripper_compat.rb#195
+ def on_when(_, _, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_while(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_while_mod(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_word_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_word_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_words_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_words_beg(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_words_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_words_sep(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#194
+ def on_xstring_add(_, _); end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_xstring_literal(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_xstring_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#193
+ def on_yield(_); end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_yield0; end
+
+ # source://prism//lib/prism/ripper_compat.rb#192
+ def on_zsuper; end
+
+ # Lazily initialize the parse result.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#188
+ def result; end
+
+ class << self
+ # This is a convenience method that runs the SexpBuilderPP subclass parser.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#171
+ def sexp(source); end
+
+ # This is a convenience method that runs the SexpBuilder subclass parser.
+ #
+ # source://prism//lib/prism/ripper_compat.rb#166
+ def sexp_raw(source); end
+ end
+end
+
+# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+# returns the arrays of [type, *children].
+#
+# source://prism//lib/prism/ripper_compat.rb#23
+class Prism::RipperCompat::SexpBuilder < ::Prism::RipperCompat
+ private
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_BEGIN(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_CHAR(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_END(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on___end__(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_alias(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_alias_error(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_aref(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_aref_field(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_arg_ambiguous(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_arg_paren(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_args_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_args_add_block(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_args_add_star(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_args_forward(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_args_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_array(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_aryptn(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_assign(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_assign_error(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_assoc_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_assoc_splat(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_assoclist_from_args(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_backref(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_backtick(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_bare_assoc_hash(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_begin(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_binary(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_block_var(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_blockarg(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_bodystmt(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_brace_block(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_break(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_call(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_case(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_class(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_class_name_error(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_comma(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_command(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_command_call(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_comment(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_const(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_const_path_field(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_const_path_ref(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_const_ref(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_cvar(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_def(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_defined(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_defs(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_do_block(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_dot2(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_dot3(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_dyna_symbol(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_else(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_elsif(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embdoc(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embdoc_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embdoc_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embexpr_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embexpr_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_embvar(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_ensure(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_excessed_comma(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_fcall(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_field(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_float(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_fndptn(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_for(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_gvar(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_hash(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_heredoc_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_heredoc_dedent(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_heredoc_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_hshptn(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_ident(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_if(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_if_mod(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_ifop(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_ignored_nl(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_ignored_sp(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_imaginary(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_in(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_int(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_ivar(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_kw(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_kwrest_param(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_label(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_label_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_lambda(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_lbrace(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_lbracket(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_lparen(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_magic_comment(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_massign(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_method_add_arg(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_method_add_block(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mlhs_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mlhs_add_post(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mlhs_add_star(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mlhs_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mlhs_paren(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_module(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mrhs_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mrhs_add_star(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mrhs_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_mrhs_new_from_args(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_next(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_nl(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_nokw_param(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_op(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_opassign(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_operator_ambiguous(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_param_error(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_params(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_paren(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_parse_error(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_period(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_program(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_qsymbols_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_qsymbols_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_qsymbols_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_qwords_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_qwords_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_qwords_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_rational(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_rbrace(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_rbracket(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_redo(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_regexp_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_regexp_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_regexp_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_regexp_literal(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_regexp_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_rescue(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_rescue_mod(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_rest_param(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_retry(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_return(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_return0(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_rparen(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_sclass(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_semicolon(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_sp(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_stmts_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_stmts_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_concat(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_content(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_dvar(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_embexpr(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_string_literal(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_super(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_symbeg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_symbol(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_symbol_literal(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_symbols_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_symbols_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_symbols_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_tlambda(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_tlambeg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_top_const_field(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_top_const_ref(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_tstring_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_tstring_content(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_tstring_end(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_unary(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_undef(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_unless(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_unless_mod(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_until(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_until_mod(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_var_alias(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_var_field(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_var_ref(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_vcall(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_void_stmt(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_when(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_while(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_while_mod(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_word_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_word_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_words_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_words_beg(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_words_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#33
+ def on_words_sep(value); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_xstring_add(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_xstring_literal(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_xstring_new(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_yield(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_yield0(*args); end
+
+ # source://prism//lib/prism/ripper_compat.rb#27
+ def on_zsuper(*args); end
+end
+
+# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
+# returns the same values as ::Ripper::SexpBuilder except with a couple of
+# niceties that flatten linked lists into arrays.
+#
+# source://prism//lib/prism/ripper_compat.rb#42
+class Prism::RipperCompat::SexpBuilderPP < ::Prism::RipperCompat::SexpBuilder
+ private
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def _dispatch_event_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def _dispatch_event_push(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_args_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_args_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_mlhs_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_mlhs_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_mrhs_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_mrhs_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_qsymbols_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_qsymbols_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_qwords_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_qwords_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_regexp_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_regexp_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_stmts_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_stmts_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_string_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_symbols_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_symbols_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_word_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_word_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_words_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_words_new; end
+
+ # source://prism//lib/prism/ripper_compat.rb#49
+ def on_xstring_add(list, item); end
+
+ # source://prism//lib/prism/ripper_compat.rb#45
+ def on_xstring_new; end
+end
+
+# Represents the `self` keyword.
+#
+# self
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#15202
+class Prism::SelfNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [SelfNode] a new instance of SelfNode
+ #
+ # source://prism//lib/prism/node.rb#15204
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15209
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15214
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15224
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15219
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SelfNode
+ #
+ # source://prism//lib/prism/node.rb#15229
+ sig { params(params: T.untyped).returns(Prism::SelfNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15214
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15239
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15244
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15263
+ 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#15273
+ def type; end
+ end
+end
+
+# A module responsible for deserializing parse results.
+#
+# source://prism//lib/prism/serialize.rb#23
+module Prism::Serialize
+ class << self
+ # Deserialize the AST represented by the given string into a parse result.
+ #
+ # source://prism//lib/prism/serialize.rb#37
+ def load(input, serialized); end
+
+ # Deserialize the tokens represented by the given string into a parse
+ # result.
+ #
+ # source://prism//lib/prism/serialize.rb#49
+ def load_tokens(source, serialized); end
+ end
+end
+
+# source://prism//lib/prism/serialize.rb#53
+class Prism::Serialize::Loader
+ # @return [Loader] a new instance of Loader
+ #
+ # source://prism//lib/prism/serialize.rb#58
+ def initialize(source, serialized); end
+
+ # Returns the value of attribute constant_pool.
+ #
+ # source://prism//lib/prism/serialize.rb#55
+ def constant_pool; end
+
+ # Returns the value of attribute constant_pool_offset.
+ #
+ # source://prism//lib/prism/serialize.rb#55
+ def constant_pool_offset; end
+
+ # Returns the value of attribute encoding.
+ #
+ # source://prism//lib/prism/serialize.rb#54
+ def encoding; end
+
+ # Returns the value of attribute input.
+ #
+ # source://prism//lib/prism/serialize.rb#54
+ def input; end
+
+ # Returns the value of attribute io.
+ #
+ # source://prism//lib/prism/serialize.rb#54
+ def io; end
+
+ # source://prism//lib/prism/serialize.rb#92
+ def load_comments; end
+
+ # source://prism//lib/prism/serialize.rb#82
+ def load_encoding; end
+
+ # source://prism//lib/prism/serialize.rb#73
+ def load_header; end
+
+ # source://prism//lib/prism/serialize.rb#102
+ def load_metadata; end
+
+ # source://prism//lib/prism/serialize.rb#135
+ def load_nodes; end
+
+ # source://prism//lib/prism/serialize.rb#148
+ def load_result; end
+
+ # source://prism//lib/prism/serialize.rb#88
+ def load_start_line; end
+
+ # source://prism//lib/prism/serialize.rb#111
+ def load_tokens; end
+
+ # source://prism//lib/prism/serialize.rb#124
+ def load_tokens_result; end
+
+ # Returns the value of attribute serialized.
+ #
+ # source://prism//lib/prism/serialize.rb#54
+ def serialized; end
+
+ # Returns the value of attribute source.
+ #
+ # source://prism//lib/prism/serialize.rb#55
+ def source; end
+
+ # Returns the value of attribute start_line.
+ #
+ # source://prism//lib/prism/serialize.rb#56
+ def start_line; end
+
+ private
+
+ # source://prism//lib/prism/serialize.rb#211
+ def load_constant(index); end
+
+ # source://prism//lib/prism/serialize.rb#187
+ def load_embedded_string; end
+
+ # source://prism//lib/prism/serialize.rb#203
+ def load_location; end
+
+ # source://prism//lib/prism/serialize.rb#242
+ def load_node; end
+
+ # source://prism//lib/prism/serialize.rb#236
+ def load_optional_constant; end
+
+ # source://prism//lib/prism/serialize.rb#207
+ def load_optional_location; end
+
+ # source://prism//lib/prism/serialize.rb#180
+ def load_optional_node; end
+
+ # source://prism//lib/prism/serialize.rb#232
+ def load_required_constant; end
+
+ # source://prism//lib/prism/serialize.rb#176
+ def load_serialized_length; end
+
+ # source://prism//lib/prism/serialize.rb#191
+ def load_string; end
+
+ # source://prism//lib/prism/serialize.rb#171
+ def load_varsint; end
+
+ # variable-length integer using https://en.wikipedia.org/wiki/LEB128
+ # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
+ #
+ # source://prism//lib/prism/serialize.rb#157
+ def load_varuint; end
+end
+
+# The major version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#26
+Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The minor version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#30
+Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The patch version of prism that we are expecting to find in the serialized
+# strings.
+#
+# source://prism//lib/prism/serialize.rb#34
+Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
+
+# The token types that can be indexed by their enum values.
+#
+# source://prism//lib/prism/serialize.rb#1154
+Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
+
+# Represents a singleton class declaration involving the `class` keyword.
+#
+# class << self end
+# ^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15282
+class Prism::SingletonClassNode < ::Prism::Node
+ # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
+ #
+ # @return [SingletonClassNode] a new instance of SingletonClassNode
+ #
+ # source://prism//lib/prism/node.rb#15302
+ 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
+ ).void
+ end
+ def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15313
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Node?
+ #
+ # source://prism//lib/prism/node.rb#15296
+ sig { returns(T.nilable(Prism::Node)) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15318
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def class_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15357
+ sig { returns(String) }
+ def class_keyword; end
+
+ # attr_reader class_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15287
+ sig { returns(Prism::Location) }
+ def class_keyword_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15331
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15323
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SingletonClassNode
+ #
+ # source://prism//lib/prism/node.rb#15336
+ sig { params(params: T.untyped).returns(Prism::SingletonClassNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15318
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15352
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15367
+ sig { returns(String) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15299
+ sig { returns(Prism::Location) }
+ def end_keyword_loc; end
+
+ # attr_reader expression: Node
+ #
+ # source://prism//lib/prism/node.rb#15293
+ sig { returns(Prism::Node) }
+ def expression; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15372
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # attr_reader locals: Array[Symbol]
+ #
+ # source://prism//lib/prism/node.rb#15284
+ sig { returns(T::Array[Symbol]) }
+ def locals; end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15362
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15290
+ 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#15403
+ 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#15413
+ 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 and newline byte
+ # offsets. If no newline byte offsets are given, they will be computed from
+ # the source code.
+ #
+ # @return [Source] a new instance of Source
+ #
+ # source://prism//lib/prism/parse_result.rb#20
+ def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
+
+ # Return the column number in characters for the given byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#55
+ def character_column(byte_offset); end
+
+ # Return the character offset for the given byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#50
+ def character_offset(byte_offset); end
+
+ # Return the column number for the given byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#45
+ def column(byte_offset); end
+
+ # Binary search through the offsets to find the line number for the given
+ # byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#34
+ def line(byte_offset); end
+
+ sig { params(value: Integer).returns(Integer) }
+ def line_offset(value); end
+
+ # Return the byte offset of the start of the line corresponding to the given
+ # byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#40
+ def line_start(byte_offset); end
+
+ # The list of newline byte offsets in the source code.
+ #
+ # source://prism//lib/prism/parse_result.rb#15
+ sig { returns(T::Array[Integer]) }
+ def offsets; end
+
+ # Perform a byteslice on the source code using the given byte offset and
+ # byte length.
+ #
+ # source://prism//lib/prism/parse_result.rb#28
+ def slice(byte_offset, length); end
+
+ # The source code that this source object represents.
+ #
+ # source://prism//lib/prism/parse_result.rb#9
+ sig { returns(String) }
+ def source; end
+
+ # The line number where this source starts.
+ #
+ # source://prism//lib/prism/parse_result.rb#12
+ def start_line; end
+
+ # The line number where this source starts.
+ #
+ # source://prism//lib/prism/parse_result.rb#12
+ def start_line=(_arg0); end
+
+ private
+
+ # Find all of the newlines in the source code and return their byte offsets
+ # from the start of the string an array.
+ #
+ # source://prism//lib/prism/parse_result.rb#83
+ def compute_offsets(code); end
+
+ # Binary search through the offsets to find the line number for the given
+ # byte offset.
+ #
+ # source://prism//lib/prism/parse_result.rb#63
+ def find_line(byte_offset); end
+end
+
+# Represents the use of the `__ENCODING__` keyword.
+#
+# __ENCODING__
+# ^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15422
+class Prism::SourceEncodingNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [SourceEncodingNode] a new instance of SourceEncodingNode
+ #
+ # source://prism//lib/prism/node.rb#15424
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15429
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15434
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15444
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15439
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SourceEncodingNode
+ #
+ # source://prism//lib/prism/node.rb#15449
+ sig { params(params: T.untyped).returns(Prism::SourceEncodingNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15434
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15459
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15464
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15483
+ 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#15493
+ def type; end
+ end
+end
+
+# Represents the use of the `__FILE__` keyword.
+#
+# __FILE__
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15502
+class Prism::SourceFileNode < ::Prism::Node
+ # def initialize: (filepath: String, location: Location) -> void
+ #
+ # @return [SourceFileNode] a new instance of SourceFileNode
+ #
+ # source://prism//lib/prism/node.rb#15507
+ sig { params(filepath: String, location: Prism::Location).void }
+ def initialize(filepath, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15513
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15518
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15528
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15523
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SourceFileNode
+ #
+ # source://prism//lib/prism/node.rb#15533
+ sig { params(params: T.untyped).returns(Prism::SourceFileNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15518
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15544
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader filepath: String
+ #
+ # source://prism//lib/prism/node.rb#15504
+ sig { returns(String) }
+ def filepath; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15549
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15569
+ 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#15579
+ def type; end
+ end
+end
+
+# Represents the use of the `__LINE__` keyword.
+#
+# __LINE__
+# ^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15588
+class Prism::SourceLineNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [SourceLineNode] a new instance of SourceLineNode
+ #
+ # source://prism//lib/prism/node.rb#15590
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15595
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15600
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15610
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15605
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SourceLineNode
+ #
+ # source://prism//lib/prism/node.rb#15615
+ sig { params(params: T.untyped).returns(Prism::SourceLineNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15600
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15625
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15630
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15649
+ 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#15659
+ def type; end
+ end
+end
+
+# Represents the use of the splat operator.
+#
+# [*a]
+# ^^
+#
+# source://prism//lib/prism/node.rb#15668
+class Prism::SplatNode < ::Prism::Node
+ # def initialize: (operator_loc: Location, expression: Node?, location: Location) -> void
+ #
+ # @return [SplatNode] a new instance of SplatNode
+ #
+ # source://prism//lib/prism/node.rb#15676
+ sig { params(operator_loc: Prism::Location, expression: T.nilable(Prism::Node), location: Prism::Location).void }
+ def initialize(operator_loc, expression, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15683
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15688
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15700
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15693
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SplatNode
+ #
+ # source://prism//lib/prism/node.rb#15705
+ sig { params(params: T.untyped).returns(Prism::SplatNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15688
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15717
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # attr_reader expression: Node?
+ #
+ # source://prism//lib/prism/node.rb#15673
+ sig { returns(T.nilable(Prism::Node)) }
+ def expression; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15727
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def operator: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15722
+ sig { returns(String) }
+ def operator; end
+
+ # attr_reader operator_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15670
+ 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#15753
+ 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#15763
+ def type; end
+ end
+end
+
+# Represents a set of statements contained within some scope.
+#
+# foo; bar; baz
+# ^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#15772
+class Prism::StatementsNode < ::Prism::Node
+ # def initialize: (body: Array[Node], location: Location) -> void
+ #
+ # @return [StatementsNode] a new instance of StatementsNode
+ #
+ # source://prism//lib/prism/node.rb#15777
+ sig { params(body: T::Array[Prism::Node], location: Prism::Location).void }
+ def initialize(body, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15783
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader body: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15774
+ sig { returns(T::Array[Prism::Node]) }
+ def body; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15788
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15798
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15793
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> StatementsNode
+ #
+ # source://prism//lib/prism/node.rb#15803
+ sig { params(params: T.untyped).returns(Prism::StatementsNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15788
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15814
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15819
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#15839
+ 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#15849
+ def type; end
+ end
+end
+
+# Flags for string nodes.
+#
+# source://prism//lib/prism/node.rb#17379
+module Prism::StringFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#17384
+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#17381
+Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
+
+# frozen by virtue of a `frozen_string_literal` comment
+#
+# source://prism//lib/prism/node.rb#17387
+Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
+
+# Represents a string literal, a string contained within a `%w` list, or
+# plain string content within an interpolated string.
+#
+# "foo"
+# ^^^^^
+#
+# %w[foo]
+# ^^^
+#
+# "foo #{bar} baz"
+# ^^^^ ^^^^
+#
+# source://prism//lib/prism/node.rb#15865
+class Prism::StringNode < ::Prism::Node
+ include ::Prism::HeredocQuery
+
+ # def initialize: (flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void
+ #
+ # @return [StringNode] a new instance of StringNode
+ #
+ # source://prism//lib/prism/node.rb#15882
+ 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
+ ).void
+ end
+ def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#15892
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15897
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#15957
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#15876
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#15907
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#15902
+ def compact_child_nodes; end
+
+ # def content: () -> String
+ #
+ # source://prism//lib/prism/node.rb#15952
+ sig { returns(String) }
+ def content; end
+
+ # attr_reader content_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#15873
+ sig { returns(Prism::Location) }
+ def content_loc; end
+
+ # def copy: (**params) -> StringNode
+ #
+ # source://prism//lib/prism/node.rb#15912
+ sig { params(params: T.untyped).returns(Prism::StringNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#15897
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#15927
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#15937
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#15932
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def frozen?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#15942
+ sig { returns(T::Boolean) }
+ def frozen?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#15962
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#15947
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#15870
+ 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#15987
+ def type; end
+
+ # attr_reader unescaped: String
+ #
+ # source://prism//lib/prism/node.rb#15879
+ sig { returns(String) }
+ def unescaped; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#15867
+ 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#15997
+ 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#16009
+class Prism::SuperNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location) -> void
+ #
+ # @return [SuperNode] a new instance of SuperNode
+ #
+ # source://prism//lib/prism/node.rb#16026
+ 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
+ ).void
+ end
+ def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16036
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#16017
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # attr_reader block: Node?
+ #
+ # source://prism//lib/prism/node.rb#16023
+ sig { returns(T.nilable(Prism::Node)) }
+ def block; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16041
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16054
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16046
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SuperNode
+ #
+ # source://prism//lib/prism/node.rb#16059
+ sig { params(params: T.untyped).returns(Prism::SuperNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16041
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16074
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16094
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16079
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16011
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16084
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16014
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16089
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16020
+ 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#16128
+ 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#16138
+ def type; end
+ end
+end
+
+# Flags for symbol nodes.
+#
+# source://prism//lib/prism/node.rb#17391
+module Prism::SymbolFlags; end
+
+# internal bytes forced the encoding to binary
+#
+# source://prism//lib/prism/node.rb#17396
+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#17399
+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#17393
+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#16150
+class Prism::SymbolNode < ::Prism::Node
+ # def initialize: (flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
+ #
+ # @return [SymbolNode] a new instance of SymbolNode
+ #
+ # source://prism//lib/prism/node.rb#16167
+ 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
+ ).void
+ end
+ def initialize(flags, opening_loc, value_loc, closing_loc, unescaped, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16177
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16182
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16242
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16161
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16192
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16187
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> SymbolNode
+ #
+ # source://prism//lib/prism/node.rb#16197
+ sig { params(params: T.untyped).returns(Prism::SymbolNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16182
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16212
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16222
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_us_ascii_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16227
+ sig { returns(T::Boolean) }
+ def forced_us_ascii_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16217
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16247
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16232
+ sig { returns(T.nilable(String)) }
+ def opening; end
+
+ # attr_reader opening_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16155
+ 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#16272
+ def type; end
+
+ # attr_reader unescaped: String
+ #
+ # source://prism//lib/prism/node.rb#16164
+ sig { returns(String) }
+ def unescaped; end
+
+ # def value: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16237
+ sig { returns(T.nilable(String)) }
+ def value; end
+
+ # attr_reader value_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16158
+ sig { returns(T.nilable(Prism::Location)) }
+ def value_loc; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#16152
+ 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#16282
+ def type; end
+ end
+end
+
+# This represents a token from the Ruby source.
+#
+# source://prism//lib/prism/parse_result.rb#416
+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#427
+ sig { params(type: T.untyped, value: String, location: Prism::Location).void }
+ def initialize(type, value, location); end
+
+ # Returns true if the given other token is equal to this token.
+ #
+ # source://prism//lib/prism/parse_result.rb#454
+ 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#434
+ sig { params(keys: T.untyped).returns(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#424
+ sig { returns(Prism::Location) }
+ def location; end
+
+ # Implement the pretty print interface for Token.
+ #
+ # source://prism//lib/prism/parse_result.rb#439
+ sig { params(q: T.untyped).returns(T.untyped) }
+ def pretty_print(q); end
+
+ # The type of token that this token is.
+ #
+ # source://prism//lib/prism/parse_result.rb#418
+ sig { returns(T.untyped) }
+ def type; end
+
+ # A byteslice of the source that this token represents.
+ #
+ # source://prism//lib/prism/parse_result.rb#421
+ sig { returns(String) }
+ def value; end
+end
+
+# Represents the use of the literal `true` keyword.
+#
+# true
+# ^^^^
+#
+# source://prism//lib/prism/node.rb#16291
+class Prism::TrueNode < ::Prism::Node
+ # def initialize: (location: Location) -> void
+ #
+ # @return [TrueNode] a new instance of TrueNode
+ #
+ # source://prism//lib/prism/node.rb#16293
+ sig { params(location: Prism::Location).void }
+ def initialize(location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16298
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16303
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16313
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16308
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> TrueNode
+ #
+ # source://prism//lib/prism/node.rb#16318
+ sig { params(params: T.untyped).returns(Prism::TrueNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16303
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16328
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16333
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#16352
+ 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#16362
+ def type; end
+ end
+end
+
+# Represents the use of the `undef` keyword.
+#
+# undef :foo, :bar, :baz
+# ^^^^^^^^^^^^^^^^^^^^^^
+#
+# source://prism//lib/prism/node.rb#16371
+class Prism::UndefNode < ::Prism::Node
+ # def initialize: (names: Array[Node], keyword_loc: Location, location: Location) -> void
+ #
+ # @return [UndefNode] a new instance of UndefNode
+ #
+ # source://prism//lib/prism/node.rb#16379
+ sig { params(names: T::Array[Prism::Node], keyword_loc: Prism::Location, location: Prism::Location).void }
+ def initialize(names, keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16386
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16391
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16401
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16396
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> UndefNode
+ #
+ # source://prism//lib/prism/node.rb#16406
+ sig { params(params: T.untyped).returns(Prism::UndefNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16391
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16418
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16428
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16423
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16376
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader names: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16373
+ sig { returns(T::Array[Prism::Node]) }
+ def names; end
+
+ # Sometimes you want to check an instance of a node against a list of
+ # classes to see what kind of behavior to perform. Usually this is done by
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
+ # these approaches are relatively slow because of the constant lookups,
+ # method calls, and/or array allocations.
+ #
+ # Instead, you can call #type, which will return to you a symbol that you
+ # can use for comparison. This is faster than the other approaches because
+ # it uses a single integer comparison, but also because if you're on CRuby
+ # you can take advantage of the fact that case statements with all symbol
+ # keys will use a jump table.
+ #
+ # def type: () -> Symbol
+ #
+ # source://prism//lib/prism/node.rb#16449
+ 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#16459
+ 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#16471
+class Prism::UnlessNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, predicate: Node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
+ #
+ # @return [UnlessNode] a new instance of UnlessNode
+ #
+ # source://prism//lib/prism/node.rb#16491
+ 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
+ ).void
+ end
+ def initialize(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16502
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16511
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16525
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16516
+ def compact_child_nodes; end
+
+ # attr_reader consequent: ElseNode?
+ #
+ # source://prism//lib/prism/node.rb#16485
+ sig { returns(T.nilable(Prism::ElseNode)) }
+ def consequent; end
+
+ # def copy: (**params) -> UnlessNode
+ #
+ # source://prism//lib/prism/node.rb#16530
+ sig { params(params: T.untyped).returns(Prism::UnlessNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16511
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16546
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def end_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16561
+ sig { returns(T.nilable(String)) }
+ def end_keyword; end
+
+ # attr_reader end_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16488
+ sig { returns(T.nilable(Prism::Location)) }
+ def end_keyword_loc; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16566
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16551
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16473
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader predicate: Node
+ #
+ # source://prism//lib/prism/node.rb#16476
+ sig { returns(Prism::Node) }
+ def predicate; end
+
+ # source://prism//lib/prism/node.rb#16506
+ def set_newline_flag(newline_marked); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#16482
+ sig { returns(T.nilable(Prism::StatementsNode)) }
+ def statements; end
+
+ # def then_keyword: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16556
+ sig { returns(T.nilable(String)) }
+ def then_keyword; end
+
+ # attr_reader then_keyword_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16479
+ 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#16602
+ 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#16612
+ 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#16624
+class Prism::UntilNode < ::Prism::Node
+ # def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
+ #
+ # @return [UntilNode] a new instance of UntilNode
+ #
+ # source://prism//lib/prism/node.rb#16641
+ 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
+ ).void
+ end
+ def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16651
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def begin_modifier?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16698
+ sig { returns(T::Boolean) }
+ def begin_modifier?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16660
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16708
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16632
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16673
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16665
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> UntilNode
+ #
+ # source://prism//lib/prism/node.rb#16678
+ sig { params(params: T.untyped).returns(Prism::UntilNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16660
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16693
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16713
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16703
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16629
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader predicate: Node
+ #
+ # source://prism//lib/prism/node.rb#16635
+ sig { returns(Prism::Node) }
+ def predicate; end
+
+ # source://prism//lib/prism/node.rb#16655
+ def set_newline_flag(newline_marked); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#16638
+ 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#16744
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#16626
+ 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#16754
+ 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#50
+class Prism::Visitor < ::Prism::BasicVisitor
+ # Visit a AliasGlobalVariableNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AliasGlobalVariableNode).void }
+ def visit_alias_global_variable_node(node); end
+
+ # Visit a AliasMethodNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AliasMethodNode).void }
+ def visit_alias_method_node(node); end
+
+ # Visit a AlternationPatternNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AlternationPatternNode).void }
+ def visit_alternation_pattern_node(node); end
+
+ # Visit a AndNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AndNode).void }
+ def visit_and_node(node); end
+
+ # Visit a ArgumentsNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ArgumentsNode).void }
+ def visit_arguments_node(node); end
+
+ # Visit a ArrayNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ArrayNode).void }
+ def visit_array_node(node); end
+
+ # Visit a ArrayPatternNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ArrayPatternNode).void }
+ def visit_array_pattern_node(node); end
+
+ # Visit a AssocNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AssocNode).void }
+ def visit_assoc_node(node); end
+
+ # Visit a AssocSplatNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::AssocSplatNode).void }
+ def visit_assoc_splat_node(node); end
+
+ # Visit a BackReferenceReadNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BackReferenceReadNode).void }
+ def visit_back_reference_read_node(node); end
+
+ # Visit a BeginNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BeginNode).void }
+ def visit_begin_node(node); end
+
+ # Visit a BlockArgumentNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BlockArgumentNode).void }
+ def visit_block_argument_node(node); end
+
+ # Visit a BlockLocalVariableNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BlockLocalVariableNode).void }
+ def visit_block_local_variable_node(node); end
+
+ # Visit a BlockNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BlockNode).void }
+ def visit_block_node(node); end
+
+ # Visit a BlockParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BlockParameterNode).void }
+ def visit_block_parameter_node(node); end
+
+ # Visit a BlockParametersNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BlockParametersNode).void }
+ def visit_block_parameters_node(node); end
+
+ # Visit a BreakNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::BreakNode).void }
+ def visit_break_node(node); end
+
+ # Visit a CallAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CallAndWriteNode).void }
+ def visit_call_and_write_node(node); end
+
+ # Visit a CallNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CallNode).void }
+ def visit_call_node(node); end
+
+ # Visit a CallOperatorWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CallOperatorWriteNode).void }
+ def visit_call_operator_write_node(node); end
+
+ # Visit a CallOrWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CallOrWriteNode).void }
+ def visit_call_or_write_node(node); end
+
+ # Visit a CallTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CallTargetNode).void }
+ def visit_call_target_node(node); end
+
+ # Visit a CapturePatternNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CapturePatternNode).void }
+ def visit_capture_pattern_node(node); end
+
+ # Visit a CaseMatchNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CaseMatchNode).void }
+ def visit_case_match_node(node); end
+
+ # Visit a CaseNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::CaseNode).void }
+ def visit_case_node(node); end
+
+ # Visit a ClassNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ClassNode).void }
+ def visit_class_node(node); end
+
+ # Visit a ClassVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ 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#26
+ 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#26
+ sig { params(node: Prism::ClassVariableReadNode).void }
+ def visit_class_variable_read_node(node); end
+
+ # Visit a ClassVariableTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ClassVariableTargetNode).void }
+ def visit_class_variable_target_node(node); end
+
+ # Visit a ClassVariableWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ClassVariableWriteNode).void }
+ def visit_class_variable_write_node(node); end
+
+ # Visit a ConstantAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantAndWriteNode).void }
+ def visit_constant_and_write_node(node); end
+
+ # Visit a ConstantOperatorWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantOperatorWriteNode).void }
+ def visit_constant_operator_write_node(node); end
+
+ # Visit a ConstantOrWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantOrWriteNode).void }
+ def visit_constant_or_write_node(node); end
+
+ # Visit a ConstantPathAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ sig { params(node: Prism::ConstantPathNode).void }
+ def visit_constant_path_node(node); end
+
+ # Visit a ConstantPathOperatorWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ 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#26
+ sig { params(node: Prism::ConstantPathTargetNode).void }
+ def visit_constant_path_target_node(node); end
+
+ # Visit a ConstantPathWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantPathWriteNode).void }
+ def visit_constant_path_write_node(node); end
+
+ # Visit a ConstantReadNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantReadNode).void }
+ def visit_constant_read_node(node); end
+
+ # Visit a ConstantTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantTargetNode).void }
+ def visit_constant_target_node(node); end
+
+ # Visit a ConstantWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ConstantWriteNode).void }
+ def visit_constant_write_node(node); end
+
+ # Visit a DefNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::DefNode).void }
+ def visit_def_node(node); end
+
+ # Visit a DefinedNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::DefinedNode).void }
+ def visit_defined_node(node); end
+
+ # Visit a ElseNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ElseNode).void }
+ def visit_else_node(node); end
+
+ # Visit a EmbeddedStatementsNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::EmbeddedStatementsNode).void }
+ def visit_embedded_statements_node(node); end
+
+ # Visit a EmbeddedVariableNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::EmbeddedVariableNode).void }
+ def visit_embedded_variable_node(node); end
+
+ # Visit a EnsureNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::EnsureNode).void }
+ def visit_ensure_node(node); end
+
+ # Visit a FalseNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::FalseNode).void }
+ def visit_false_node(node); end
+
+ # Visit a FindPatternNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::FindPatternNode).void }
+ def visit_find_pattern_node(node); end
+
+ # Visit a FlipFlopNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::FlipFlopNode).void }
+ def visit_flip_flop_node(node); end
+
+ # Visit a FloatNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::FloatNode).void }
+ def visit_float_node(node); end
+
+ # Visit a ForNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ForNode).void }
+ def visit_for_node(node); end
+
+ # Visit a ForwardingArgumentsNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ForwardingArgumentsNode).void }
+ def visit_forwarding_arguments_node(node); end
+
+ # Visit a ForwardingParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ForwardingParameterNode).void }
+ def visit_forwarding_parameter_node(node); end
+
+ # Visit a ForwardingSuperNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ForwardingSuperNode).void }
+ def visit_forwarding_super_node(node); end
+
+ # Visit a GlobalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ 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#26
+ 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#26
+ sig { params(node: Prism::GlobalVariableReadNode).void }
+ def visit_global_variable_read_node(node); end
+
+ # Visit a GlobalVariableTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::GlobalVariableTargetNode).void }
+ def visit_global_variable_target_node(node); end
+
+ # Visit a GlobalVariableWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::GlobalVariableWriteNode).void }
+ def visit_global_variable_write_node(node); end
+
+ # Visit a HashNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::HashNode).void }
+ def visit_hash_node(node); end
+
+ # Visit a HashPatternNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::HashPatternNode).void }
+ def visit_hash_pattern_node(node); end
+
+ # Visit a IfNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IfNode).void }
+ def visit_if_node(node); end
+
+ # Visit a ImaginaryNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ImaginaryNode).void }
+ def visit_imaginary_node(node); end
+
+ # Visit a ImplicitNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ImplicitNode).void }
+ def visit_implicit_node(node); end
+
+ # Visit a ImplicitRestNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ImplicitRestNode).void }
+ def visit_implicit_rest_node(node); end
+
+ # Visit a InNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InNode).void }
+ def visit_in_node(node); end
+
+ # Visit a IndexAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IndexAndWriteNode).void }
+ def visit_index_and_write_node(node); end
+
+ # Visit a IndexOperatorWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IndexOperatorWriteNode).void }
+ def visit_index_operator_write_node(node); end
+
+ # Visit a IndexOrWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IndexOrWriteNode).void }
+ def visit_index_or_write_node(node); end
+
+ # Visit a IndexTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IndexTargetNode).void }
+ def visit_index_target_node(node); end
+
+ # Visit a InstanceVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ 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#26
+ 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#26
+ sig { params(node: Prism::InstanceVariableReadNode).void }
+ def visit_instance_variable_read_node(node); end
+
+ # Visit a InstanceVariableTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InstanceVariableTargetNode).void }
+ def visit_instance_variable_target_node(node); end
+
+ # Visit a InstanceVariableWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InstanceVariableWriteNode).void }
+ def visit_instance_variable_write_node(node); end
+
+ # Visit a IntegerNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::IntegerNode).void }
+ def visit_integer_node(node); end
+
+ # Visit a InterpolatedMatchLastLineNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ sig { params(node: Prism::InterpolatedRegularExpressionNode).void }
+ def visit_interpolated_regular_expression_node(node); end
+
+ # Visit a InterpolatedStringNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InterpolatedStringNode).void }
+ def visit_interpolated_string_node(node); end
+
+ # Visit a InterpolatedSymbolNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InterpolatedSymbolNode).void }
+ def visit_interpolated_symbol_node(node); end
+
+ # Visit a InterpolatedXStringNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::InterpolatedXStringNode).void }
+ def visit_interpolated_x_string_node(node); end
+
+ # Visit a KeywordHashNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::KeywordHashNode).void }
+ def visit_keyword_hash_node(node); end
+
+ # Visit a KeywordRestParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::KeywordRestParameterNode).void }
+ def visit_keyword_rest_parameter_node(node); end
+
+ # Visit a LambdaNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::LambdaNode).void }
+ def visit_lambda_node(node); end
+
+ # Visit a LocalVariableAndWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#26
+ 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#26
+ 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#26
+ sig { params(node: Prism::LocalVariableReadNode).void }
+ def visit_local_variable_read_node(node); end
+
+ # Visit a LocalVariableTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::LocalVariableTargetNode).void }
+ def visit_local_variable_target_node(node); end
+
+ # Visit a LocalVariableWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::LocalVariableWriteNode).void }
+ def visit_local_variable_write_node(node); end
+
+ # Visit a MatchLastLineNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MatchLastLineNode).void }
+ def visit_match_last_line_node(node); end
+
+ # Visit a MatchPredicateNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MatchPredicateNode).void }
+ def visit_match_predicate_node(node); end
+
+ # Visit a MatchRequiredNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MatchRequiredNode).void }
+ def visit_match_required_node(node); end
+
+ # Visit a MatchWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MatchWriteNode).void }
+ def visit_match_write_node(node); end
+
+ # Visit a MissingNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MissingNode).void }
+ def visit_missing_node(node); end
+
+ # Visit a ModuleNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ModuleNode).void }
+ def visit_module_node(node); end
+
+ # Visit a MultiTargetNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MultiTargetNode).void }
+ def visit_multi_target_node(node); end
+
+ # Visit a MultiWriteNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::MultiWriteNode).void }
+ def visit_multi_write_node(node); end
+
+ # Visit a NextNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::NextNode).void }
+ def visit_next_node(node); end
+
+ # Visit a NilNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::NilNode).void }
+ def visit_nil_node(node); end
+
+ # Visit a NoKeywordsParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::NoKeywordsParameterNode).void }
+ def visit_no_keywords_parameter_node(node); end
+
+ # Visit a NumberedParametersNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::NumberedParametersNode).void }
+ def visit_numbered_parameters_node(node); end
+
+ # Visit a NumberedReferenceReadNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::NumberedReferenceReadNode).void }
+ def visit_numbered_reference_read_node(node); end
+
+ # Visit a OptionalKeywordParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::OptionalKeywordParameterNode).void }
+ def visit_optional_keyword_parameter_node(node); end
+
+ # Visit a OptionalParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::OptionalParameterNode).void }
+ def visit_optional_parameter_node(node); end
+
+ # Visit a OrNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::OrNode).void }
+ def visit_or_node(node); end
+
+ # Visit a ParametersNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ParametersNode).void }
+ def visit_parameters_node(node); end
+
+ # Visit a ParenthesesNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ParenthesesNode).void }
+ def visit_parentheses_node(node); end
+
+ # Visit a PinnedExpressionNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::PinnedExpressionNode).void }
+ def visit_pinned_expression_node(node); end
+
+ # Visit a PinnedVariableNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::PinnedVariableNode).void }
+ def visit_pinned_variable_node(node); end
+
+ # Visit a PostExecutionNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::PostExecutionNode).void }
+ def visit_post_execution_node(node); end
+
+ # Visit a PreExecutionNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::PreExecutionNode).void }
+ def visit_pre_execution_node(node); end
+
+ # Visit a ProgramNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ProgramNode).void }
+ def visit_program_node(node); end
+
+ # Visit a RangeNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RangeNode).void }
+ def visit_range_node(node); end
+
+ # Visit a RationalNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RationalNode).void }
+ def visit_rational_node(node); end
+
+ # Visit a RedoNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RedoNode).void }
+ def visit_redo_node(node); end
+
+ # Visit a RegularExpressionNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RegularExpressionNode).void }
+ def visit_regular_expression_node(node); end
+
+ # Visit a RequiredKeywordParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RequiredKeywordParameterNode).void }
+ def visit_required_keyword_parameter_node(node); end
+
+ # Visit a RequiredParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RequiredParameterNode).void }
+ def visit_required_parameter_node(node); end
+
+ # Visit a RescueModifierNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RescueModifierNode).void }
+ def visit_rescue_modifier_node(node); end
+
+ # Visit a RescueNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RescueNode).void }
+ def visit_rescue_node(node); end
+
+ # Visit a RestParameterNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RestParameterNode).void }
+ def visit_rest_parameter_node(node); end
+
+ # Visit a RetryNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::RetryNode).void }
+ def visit_retry_node(node); end
+
+ # Visit a ReturnNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::ReturnNode).void }
+ def visit_return_node(node); end
+
+ # Visit a SelfNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SelfNode).void }
+ def visit_self_node(node); end
+
+ # Visit a SingletonClassNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SingletonClassNode).void }
+ def visit_singleton_class_node(node); end
+
+ # Visit a SourceEncodingNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SourceEncodingNode).void }
+ def visit_source_encoding_node(node); end
+
+ # Visit a SourceFileNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SourceFileNode).void }
+ def visit_source_file_node(node); end
+
+ # Visit a SourceLineNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SourceLineNode).void }
+ def visit_source_line_node(node); end
+
+ # Visit a SplatNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SplatNode).void }
+ def visit_splat_node(node); end
+
+ # Visit a StatementsNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::StatementsNode).void }
+ def visit_statements_node(node); end
+
+ # Visit a StringNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::StringNode).void }
+ def visit_string_node(node); end
+
+ # Visit a SuperNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SuperNode).void }
+ def visit_super_node(node); end
+
+ # Visit a SymbolNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::SymbolNode).void }
+ def visit_symbol_node(node); end
+
+ # Visit a TrueNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::TrueNode).void }
+ def visit_true_node(node); end
+
+ # Visit a UndefNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::UndefNode).void }
+ def visit_undef_node(node); end
+
+ # Visit a UnlessNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::UnlessNode).void }
+ def visit_unless_node(node); end
+
+ # Visit a UntilNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::UntilNode).void }
+ def visit_until_node(node); end
+
+ # Visit a WhenNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::WhenNode).void }
+ def visit_when_node(node); end
+
+ # Visit a WhileNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::WhileNode).void }
+ def visit_while_node(node); end
+
+ # Visit a XStringNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ sig { params(node: Prism::XStringNode).void }
+ def visit_x_string_node(node); end
+
+ # Visit a YieldNode node
+ #
+ # source://prism//lib/prism/visitor.rb#26
+ 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#16765
+class Prism::WhenNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void
+ #
+ # @return [WhenNode] a new instance of WhenNode
+ #
+ # source://prism//lib/prism/node.rb#16776
+ sig do
+ params(
+ keyword_loc: Prism::Location,
+ conditions: T::Array[Prism::Node],
+ statements: T.nilable(Prism::StatementsNode),
+ location: Prism::Location
+ ).void
+ end
+ def initialize(keyword_loc, conditions, statements, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16784
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16789
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16802
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16794
+ def compact_child_nodes; end
+
+ # attr_reader conditions: Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16770
+ sig { returns(T::Array[Prism::Node]) }
+ def conditions; end
+
+ # def copy: (**params) -> WhenNode
+ #
+ # source://prism//lib/prism/node.rb#16807
+ sig { params(params: T.untyped).returns(Prism::WhenNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16789
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16820
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16830
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16825
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16767
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#16773
+ 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#16857
+ 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#16867
+ 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#16879
+class Prism::WhileNode < ::Prism::Node
+ # def initialize: (flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, location: Location) -> void
+ #
+ # @return [WhileNode] a new instance of WhileNode
+ #
+ # source://prism//lib/prism/node.rb#16896
+ 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
+ ).void
+ end
+ def initialize(flags, keyword_loc, closing_loc, predicate, statements, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#16906
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def begin_modifier?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#16953
+ sig { returns(T::Boolean) }
+ def begin_modifier?; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16915
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#16963
+ sig { returns(T.nilable(String)) }
+ def closing; end
+
+ # attr_reader closing_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#16887
+ sig { returns(T.nilable(Prism::Location)) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#16928
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#16920
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> WhileNode
+ #
+ # source://prism//lib/prism/node.rb#16933
+ sig { params(params: T.untyped).returns(Prism::WhileNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#16915
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#16948
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#16968
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#16958
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#16884
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # attr_reader predicate: Node
+ #
+ # source://prism//lib/prism/node.rb#16890
+ sig { returns(Prism::Node) }
+ def predicate; end
+
+ # source://prism//lib/prism/node.rb#16910
+ def set_newline_flag(newline_marked); end
+
+ # attr_reader statements: StatementsNode?
+ #
+ # source://prism//lib/prism/node.rb#16893
+ 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#16999
+ def type; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#16881
+ 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#17009
+ def type; end
+ end
+end
+
+# Represents an xstring literal with no interpolation.
+#
+# `foo`
+# ^^^^^
+#
+# source://prism//lib/prism/node.rb#17018
+class Prism::XStringNode < ::Prism::Node
+ include ::Prism::HeredocQuery
+
+ # def initialize: (flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+ #
+ # @return [XStringNode] a new instance of XStringNode
+ #
+ # source://prism//lib/prism/node.rb#17035
+ sig do
+ params(
+ flags: Integer,
+ opening_loc: Prism::Location,
+ content_loc: Prism::Location,
+ closing_loc: Prism::Location,
+ unescaped: String,
+ location: Prism::Location
+ ).void
+ end
+ def initialize(flags, opening_loc, content_loc, closing_loc, unescaped, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#17045
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#17050
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def closing: () -> String
+ #
+ # source://prism//lib/prism/node.rb#17105
+ sig { returns(String) }
+ def closing; end
+
+ # attr_reader closing_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#17029
+ sig { returns(Prism::Location) }
+ def closing_loc; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#17060
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#17055
+ def compact_child_nodes; end
+
+ # def content: () -> String
+ #
+ # source://prism//lib/prism/node.rb#17100
+ sig { returns(String) }
+ def content; end
+
+ # attr_reader content_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#17026
+ sig { returns(Prism::Location) }
+ def content_loc; end
+
+ # def copy: (**params) -> XStringNode
+ #
+ # source://prism//lib/prism/node.rb#17065
+ sig { params(params: T.untyped).returns(Prism::XStringNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#17050
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#17080
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def forced_binary_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#17090
+ sig { returns(T::Boolean) }
+ def forced_binary_encoding?; end
+
+ # def forced_utf8_encoding?: () -> bool
+ #
+ # @return [Boolean]
+ #
+ # source://prism//lib/prism/node.rb#17085
+ sig { returns(T::Boolean) }
+ def forced_utf8_encoding?; end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#17110
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def opening: () -> String
+ #
+ # source://prism//lib/prism/node.rb#17095
+ sig { returns(String) }
+ def opening; end
+
+ # attr_reader opening_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#17023
+ 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#17135
+ def type; end
+
+ # attr_reader unescaped: String
+ #
+ # source://prism//lib/prism/node.rb#17032
+ sig { returns(String) }
+ def unescaped; end
+
+ private
+
+ # Returns the value of attribute flags.
+ #
+ # source://prism//lib/prism/node.rb#17020
+ 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#17145
+ def type; end
+ end
+end
+
+# Represents the use of the `yield` keyword.
+#
+# yield 1
+# ^^^^^^^
+#
+# source://prism//lib/prism/node.rb#17154
+class Prism::YieldNode < ::Prism::Node
+ # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void
+ #
+ # @return [YieldNode] a new instance of YieldNode
+ #
+ # source://prism//lib/prism/node.rb#17168
+ 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
+ ).void
+ end
+ def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location); end
+
+ # def accept: (visitor: Visitor) -> void
+ #
+ # source://prism//lib/prism/node.rb#17177
+ sig { params(visitor: Prism::Visitor).void }
+ def accept(visitor); end
+
+ # attr_reader arguments: ArgumentsNode?
+ #
+ # source://prism//lib/prism/node.rb#17162
+ sig { returns(T.nilable(Prism::ArgumentsNode)) }
+ def arguments; end
+
+ # def child_nodes: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#17182
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def child_nodes; end
+
+ # def comment_targets: () -> Array[Node | Location]
+ #
+ # source://prism//lib/prism/node.rb#17194
+ def comment_targets; end
+
+ # def compact_child_nodes: () -> Array[Node]
+ #
+ # source://prism//lib/prism/node.rb#17187
+ def compact_child_nodes; end
+
+ # def copy: (**params) -> YieldNode
+ #
+ # source://prism//lib/prism/node.rb#17199
+ sig { params(params: T.untyped).returns(Prism::YieldNode) }
+ def copy(**params); end
+
+ # def child_nodes: () -> Array[nil | Node]
+ # def deconstruct: () -> Array[nil | Node]
+ #
+ # source://prism//lib/prism/node.rb#17182
+ sig { returns(T::Array[T.nilable(Prism::Node)]) }
+ def deconstruct; end
+
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+ #
+ # source://prism//lib/prism/node.rb#17213
+ sig do
+ params(
+ keys: T::Array[Symbol]
+ ).returns(T::Hash[Symbol, T.nilable(T.any(Prism::Node, T::Array[Prism::Node], String, Prism::Token, T::Array[Prism::Token], Prism::Location))])
+ end
+ def deconstruct_keys(keys); end
+
+ # def inspect(inspector: NodeInspector) -> String
+ #
+ # source://prism//lib/prism/node.rb#17233
+ def inspect(inspector = T.unsafe(nil)); end
+
+ # def keyword: () -> String
+ #
+ # source://prism//lib/prism/node.rb#17218
+ sig { returns(String) }
+ def keyword; end
+
+ # attr_reader keyword_loc: Location
+ #
+ # source://prism//lib/prism/node.rb#17156
+ sig { returns(Prism::Location) }
+ def keyword_loc; end
+
+ # def lparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#17223
+ sig { returns(T.nilable(String)) }
+ def lparen; end
+
+ # attr_reader lparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#17159
+ sig { returns(T.nilable(Prism::Location)) }
+ def lparen_loc; end
+
+ # def rparen: () -> String?
+ #
+ # source://prism//lib/prism/node.rb#17228
+ sig { returns(T.nilable(String)) }
+ def rparen; end
+
+ # attr_reader rparen_loc: Location?
+ #
+ # source://prism//lib/prism/node.rb#17165
+ 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#17261
+ 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#17271
+ def type; end
+ end
+end
diff --git a/2023/sorbet/rbi/gems/rbi@0.1.6.rbi b/2023/sorbet/rbi/gems/rbi@0.1.6.rbi
new file mode 100644
index 0000000..62a6362
--- /dev/null
+++ b/2023/sorbet/rbi/gems/rbi@0.1.6.rbi
@@ -0,0 +1,2922 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rbi` gem.
+# Please instead update this file by running `bin/tapioca gem rbi`.
+
+# source://rbi//lib/rbi/loc.rb#4
+module RBI; end
+
+# source://rbi//lib/rbi/model.rb#968
+class RBI::Arg < ::RBI::Node
+ # source://rbi//lib/rbi/model.rb#980
+ sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void }
+ def initialize(value, loc: T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/model.rb#986
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#613
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#991
+ sig { returns(::String) }
+ def to_s; end
+
+ # source://rbi//lib/rbi/model.rb#972
+ sig { returns(::String) }
+ def value; end
+end
+
+# Attributes
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#349
+class RBI::Attr < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#374
+ sig do
+ params(
+ name: ::Symbol,
+ names: T::Array[::Symbol],
+ visibility: ::RBI::Visibility,
+ sigs: T::Array[::RBI::Sig],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment]
+ ).void
+ 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/printer.rb#348
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#412
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/model.rb#382
+ 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#420
+ sig { override.params(other: ::RBI::Node).void }
+ def merge_with(other); end
+
+ # source://rbi//lib/rbi/model.rb#356
+ sig { returns(T::Array[::Symbol]) }
+ def names; end
+
+ # source://rbi//lib/rbi/printer.rb#375
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # source://rbi//lib/rbi/model.rb#362
+ sig { returns(T::Array[::RBI::Sig]) }
+ def sigs; end
+
+ # source://rbi//lib/rbi/model.rb#359
+ sig { returns(::RBI::Visibility) }
+ def visibility; end
+
+ # @return [Visibility]
+ #
+ # source://rbi//lib/rbi/model.rb#359
+ def visibility=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#385
+class RBI::AttrAccessor < ::RBI::Attr
+ # source://rbi//lib/rbi/model.rb#399
+ sig do
+ params(
+ name: ::Symbol,
+ names: ::Symbol,
+ visibility: ::RBI::Visibility,
+ sigs: T::Array[::RBI::Sig],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::AttrAccessor).void)
+ ).void
+ 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#452
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#405
+ sig { override.returns(T::Array[::String]) }
+ def fully_qualified_names; end
+
+ # source://rbi//lib/rbi/model.rb#411
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#417
+class RBI::AttrReader < ::RBI::Attr
+ # source://rbi//lib/rbi/model.rb#431
+ sig do
+ params(
+ name: ::Symbol,
+ names: ::Symbol,
+ visibility: ::RBI::Visibility,
+ sigs: T::Array[::RBI::Sig],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::AttrReader).void)
+ ).void
+ 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#434
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#437
+ sig { override.returns(T::Array[::String]) }
+ def fully_qualified_names; end
+
+ # source://rbi//lib/rbi/model.rb#443
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#449
+class RBI::AttrWriter < ::RBI::Attr
+ # source://rbi//lib/rbi/model.rb#463
+ sig do
+ params(
+ name: ::Symbol,
+ names: ::Symbol,
+ visibility: ::RBI::Visibility,
+ sigs: T::Array[::RBI::Sig],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::AttrWriter).void)
+ ).void
+ 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#443
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#469
+ sig { override.returns(T::Array[::String]) }
+ def fully_qualified_names; end
+
+ # source://rbi//lib/rbi/model.rb#475
+ 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#74
+class RBI::BlankLine < ::RBI::Comment
+ # source://rbi//lib/rbi/model.rb#78
+ sig { params(loc: T.nilable(::RBI::Loc)).void }
+ def initialize(loc: T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/printer.rb#217
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+end
+
+# source://rbi//lib/rbi/model.rb#741
+class RBI::BlockParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#752
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::BlockParam).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#763
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#543
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#548
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#758
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#218
+class RBI::Class < ::RBI::Scope
+ # source://rbi//lib/rbi/model.rb#236
+ sig do
+ params(
+ name: ::String,
+ superclass_name: T.nilable(::String),
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Class).void)
+ ).void
+ 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#376
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#244
+ sig { override.returns(::String) }
+ def fully_qualified_name; end
+
+ # source://rbi//lib/rbi/model.rb#222
+ sig { returns(::String) }
+ def name; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#222
+ def name=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#284
+ sig { override.params(v: ::RBI::Printer).void }
+ def print_header(v); end
+
+ # source://rbi//lib/rbi/model.rb#225
+ sig { returns(T.nilable(::String)) }
+ def superclass_name; end
+
+ # @return [String, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#225
+ def superclass_name=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#53
+class RBI::Comment < ::RBI::Node
+ # source://rbi//lib/rbi/model.rb#60
+ sig { params(text: ::String, loc: T.nilable(::RBI::Loc)).void }
+ def initialize(text, loc: T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/model.rb#66
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#197
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#57
+ sig { returns(::String) }
+ def text; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#57
+ def text=(_arg0); end
+end
+
+# A tree showing incompatibles nodes
+#
+# Is rendered as a merge conflict between `left` and` right`:
+# ~~~rb
+# class Foo
+# <<<<<<< left
+# def m1; end
+# def m2(a); end
+# =======
+# def m1(a); end
+# def m2; end
+# >>>>>>> right
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#589
+class RBI::ConflictTree < ::RBI::Tree
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#596
+ 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#607
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#593
+ sig { returns(::RBI::Tree) }
+ def left; end
+
+ # @return [Tree]
+ #
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#593
+ def right; end
+end
+
+# Consts
+#
+# source://rbi//lib/rbi/model.rb#312
+class RBI::Const < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#327
+ sig do
+ params(
+ name: ::String,
+ value: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Const).void)
+ ).void
+ end
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/printer.rb#335
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#403
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#335
+ 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#316
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/model.rb#342
+ sig { override.returns(::String) }
+ def to_s; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#316
+ def value; end
+end
+
+# source://rbi//lib/rbi/model.rb#816
+class RBI::Extend < ::RBI::Mixin
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#828
+ sig do
+ params(
+ name: ::String,
+ names: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Extend).void)
+ ).void
+ end
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#502
+ 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#834
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#137
+class RBI::File
+ # source://rbi//lib/rbi/model.rb#156
+ sig do
+ params(
+ strictness: T.nilable(::String),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(file: ::RBI::File).void)
+ ).void
+ end
+ def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#164
+ sig { params(node: ::RBI::Node).void }
+ def <<(node); end
+
+ # source://rbi//lib/rbi/printer.rb#105
+ sig { params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#147
+ sig { returns(T::Array[::RBI::Comment]) }
+ def comments; end
+
+ # @return [Array]
+ #
+ # source://rbi//lib/rbi/model.rb#147
+ def comments=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#169
+ sig { returns(T::Boolean) }
+ def empty?; end
+
+ # source://rbi//lib/rbi/printer.rb#129
+ sig do
+ params(
+ out: T.any(::IO, ::StringIO),
+ indent: ::Integer,
+ print_locs: T::Boolean,
+ max_line_length: T.nilable(::Integer)
+ ).void
+ 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#141
+ sig { returns(::RBI::Tree) }
+ def root; end
+
+ # @return [Tree]
+ #
+ # source://rbi//lib/rbi/model.rb#141
+ def root=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#144
+ sig { returns(T.nilable(::String)) }
+ def strictness; end
+
+ # @return [String, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#144
+ def strictness=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#135
+ 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#36
+ 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,
+ 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
+
+ # source://rbi//lib/rbi/formatter.rb#15
+ sig { params(add_sig_templates: T::Boolean).returns(T::Boolean) }
+ def add_sig_templates=(add_sig_templates); end
+
+ # source://rbi//lib/rbi/formatter.rb#59
+ sig { params(file: ::RBI::File).void }
+ def format_file(file); end
+
+ # source://rbi//lib/rbi/formatter.rb#64
+ sig { params(tree: ::RBI::Tree).void }
+ def format_tree(tree); end
+
+ # source://rbi//lib/rbi/formatter.rb#18
+ sig { params(group_nodes: T::Boolean).returns(T::Boolean) }
+ def group_nodes=(group_nodes); end
+
+ # source://rbi//lib/rbi/formatter.rb#24
+ sig { returns(T.nilable(::Integer)) }
+ def max_line_length; end
+
+ # @return [Integer, nil]
+ #
+ # source://rbi//lib/rbi/formatter.rb#24
+ def max_line_length=(_arg0); end
+
+ # source://rbi//lib/rbi/formatter.rb#21
+ sig { params(nest_non_public_methods: T::Boolean).returns(T::Boolean) }
+ def nest_non_public_methods=(nest_non_public_methods); end
+
+ # source://rbi//lib/rbi/formatter.rb#12
+ sig { params(nest_singleton_methods: T::Boolean).returns(T::Boolean) }
+ def nest_singleton_methods=(nest_singleton_methods); end
+
+ # source://rbi//lib/rbi/formatter.rb#53
+ 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#88
+class RBI::Group < ::RBI::Tree
+ # source://rbi//lib/rbi/rewriters/group_nodes.rb#95
+ sig { params(kind: ::RBI::Group::Kind).void }
+ def initialize(kind); end
+
+ # source://rbi//lib/rbi/printer.rb#838
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/group_nodes.rb#92
+ sig { returns(::RBI::Group::Kind) }
+ def kind; end
+end
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#100
+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
+ Inits = new
+ Methods = new
+ SingletonClasses = new
+ Consts = new
+ end
+end
+
+# Sorbet's misc.
+#
+# source://rbi//lib/rbi/model.rb#1294
+class RBI::Helper < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1308
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Helper).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/printer.rb#825
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#520
+ 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#1298
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/model.rb#1315
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#793
+class RBI::Include < ::RBI::Mixin
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#805
+ sig do
+ params(
+ name: ::String,
+ names: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Include).void)
+ ).void
+ end
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#493
+ 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#811
+ 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
+end
+
+# A Node that can be refered 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!
+
+ # Unique IDs that refer to this node.
+ #
+ # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the
+ # 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#996
+class RBI::KwArg < ::RBI::Arg
+ # source://rbi//lib/rbi/model.rb#1009
+ 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#1015
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#622
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#1000
+ sig { returns(::String) }
+ def keyword; end
+
+ # source://rbi//lib/rbi/model.rb#1020
+ sig { returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#682
+class RBI::KwOptParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#697
+ sig do
+ params(
+ name: ::String,
+ value: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::KwOptParam).void)
+ ).void
+ end
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#709
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#513
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#518
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#704
+ sig { override.returns(::String) }
+ def to_s; end
+
+ # source://rbi//lib/rbi/model.rb#686
+ sig { returns(::String) }
+ def value; end
+end
+
+# source://rbi//lib/rbi/model.rb#655
+class RBI::KwParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#666
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::KwParam).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#677
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#498
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#503
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#672
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#714
+class RBI::KwRestParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#725
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::KwRestParam).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#736
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#528
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#533
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#731
+ 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),
+ begin_line: T.nilable(::Integer),
+ end_line: T.nilable(::Integer),
+ begin_column: T.nilable(::Integer),
+ end_column: T.nilable(::Integer)
+ ).void
+ end
+ 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),
+ comments: T::Array[::RBI::Comment],
+ conflicts: T::Array[::RBI::Rewriters::Merge::Conflict],
+ block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+ ).void
+ 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#483
+class RBI::Method < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#513
+ sig do
+ params(
+ name: ::String,
+ params: T::Array[::RBI::Param],
+ is_singleton: T::Boolean,
+ visibility: ::RBI::Visibility,
+ sigs: T::Array[::RBI::Sig],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Method).void)
+ ).void
+ 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#533
+ sig { params(param: ::RBI::Param).void }
+ def <<(param); end
+
+ # source://rbi//lib/rbi/printer.rb#384
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#461
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#538
+ 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/printer.rb#437
+ sig { returns(T::Boolean) }
+ def inline_params?; end
+
+ # source://rbi//lib/rbi/model.rb#493
+ sig { returns(T::Boolean) }
+ def is_singleton; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#493
+ def is_singleton=(_arg0); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#470
+ sig { override.params(other: ::RBI::Node).void }
+ def merge_with(other); end
+
+ # source://rbi//lib/rbi/model.rb#487
+ sig { returns(::String) }
+ def name; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#487
+ def name=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#432
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # source://rbi//lib/rbi/model.rb#490
+ sig { returns(T::Array[::RBI::Param]) }
+ def params; end
+
+ # source://rbi//lib/rbi/model.rb#499
+ sig { returns(T::Array[::RBI::Sig]) }
+ def sigs; end
+
+ # @return [Array]
+ #
+ # source://rbi//lib/rbi/model.rb#499
+ def sigs=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#547
+ sig { override.returns(::String) }
+ def to_s; end
+
+ # source://rbi//lib/rbi/model.rb#496
+ sig { returns(::RBI::Visibility) }
+ def visibility; end
+
+ # @return [Visibility]
+ #
+ # source://rbi//lib/rbi/model.rb#496
+ def visibility=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#1355
+class RBI::MixesInClassMethods < ::RBI::Mixin
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1367
+ sig do
+ params(
+ name: ::String,
+ names: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::MixesInClassMethods).void)
+ ).void
+ end
+ def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#511
+ 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#1373
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# Mixins
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#770
+class RBI::Mixin < ::RBI::NodeWithComments
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#787
+ sig do
+ params(
+ name: ::String,
+ names: T::Array[::String],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment]
+ ).void
+ end
+ def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/printer.rb#558
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#484
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#777
+ sig { returns(T::Array[::String]) }
+ def names; end
+end
+
+# source://rbi//lib/rbi/model.rb#190
+class RBI::Module < ::RBI::Scope
+ # source://rbi//lib/rbi/model.rb#204
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Module).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#385
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#211
+ sig { override.returns(::String) }
+ def fully_qualified_name; end
+
+ # source://rbi//lib/rbi/model.rb#194
+ sig { returns(::String) }
+ def name; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#194
+ def name=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#270
+ sig { override.params(v: ::RBI::Printer).void }
+ def print_header(v); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#5
+class RBI::Node
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#18
+ sig { params(loc: T.nilable(::RBI::Loc)).void }
+ def initialize(loc: T.unsafe(nil)); end
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/printer.rb#146
+ sig { abstract.params(v: ::RBI::Printer).void }
+ def accept_printer(v); 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#24
+ sig { void }
+ def detach; end
+
+ # source://rbi//lib/rbi/rewriters/group_nodes.rb#48
+ sig { returns(::RBI::Group::Kind) }
+ def group_kind; end
+
+ # source://rbi//lib/rbi/model.rb#15
+ sig { returns(T.nilable(::RBI::Loc)) }
+ def loc; end
+
+ # @return [Loc, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#15
+ 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/printer.rb#179
+ sig { returns(T::Boolean) }
+ def oneline?; 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#46
+ sig { returns(T.nilable(::RBI::Scope)) }
+ def parent_scope; end
+
+ # source://rbi//lib/rbi/model.rb#12
+ sig { returns(T.nilable(::RBI::Tree)) }
+ def parent_tree; end
+
+ # @return [Tree, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#12
+ def parent_tree=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#156
+ sig do
+ params(
+ out: T.any(::IO, ::StringIO),
+ indent: ::Integer,
+ print_locs: T::Boolean,
+ max_line_length: T.nilable(::Integer)
+ ).void
+ 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/printer.rb#169
+ sig { params(v: ::RBI::Printer).void }
+ def print_blank_line_before(v); end
+
+ # source://rbi//lib/rbi/model.rb#33
+ sig { params(node: ::RBI::Node).void }
+ def replace(node); end
+
+ # source://rbi//lib/rbi/printer.rb#162
+ 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#83
+class RBI::NodeWithComments < ::RBI::Node
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#93
+ 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#99
+ sig { returns(T::Array[::String]) }
+ def annotations; end
+
+ # source://rbi//lib/rbi/model.rb#90
+ sig { returns(T::Array[::RBI::Comment]) }
+ def comments; end
+
+ # @return [Array]
+ #
+ # source://rbi//lib/rbi/model.rb#90
+ 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/printer.rb#188
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+end
+
+# source://rbi//lib/rbi/model.rb#601
+class RBI::OptParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#616
+ sig do
+ params(
+ name: ::String,
+ value: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::OptParam).void)
+ ).void
+ end
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#623
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#468
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#473
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#605
+ 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#552
+class RBI::Param < ::RBI::NodeWithComments
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#568
+ 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/printer.rb#446
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#459
+ sig { returns(T::Array[::String]) }
+ def comments_lines; end
+
+ # source://rbi//lib/rbi/model.rb#559
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/printer.rb#451
+ sig { params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#574
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/parser.rb#7
+class RBI::ParseError < ::StandardError
+ # 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
+
+ # 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)
+ ).returns(T.nilable(::RBI::Struct))
+ 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#5
+class RBI::Printer < ::RBI::Visitor
+ # source://rbi//lib/rbi/printer.rb#28
+ sig do
+ params(
+ out: T.any(::IO, ::StringIO),
+ indent: ::Integer,
+ print_locs: T::Boolean,
+ max_line_length: T.nilable(::Integer)
+ ).void
+ 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#15
+ sig { returns(::Integer) }
+ def current_indent; end
+
+ # source://rbi//lib/rbi/printer.rb#46
+ sig { void }
+ def dedent; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/printer.rb#9
+ def in_visibility_group; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/printer.rb#9
+ def in_visibility_group=(_arg0); end
+
+ # Printing
+ #
+ # source://rbi//lib/rbi/printer.rb#41
+ sig { void }
+ def indent; end
+
+ # source://rbi//lib/rbi/printer.rb#18
+ sig { returns(T.nilable(::Integer)) }
+ def max_line_length; end
+
+ # source://rbi//lib/rbi/printer.rb#12
+ 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#52
+ sig { params(string: ::String).void }
+ def print(string); end
+
+ # source://rbi//lib/rbi/printer.rb#9
+ sig { returns(T::Boolean) }
+ def print_locs; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/printer.rb#9
+ def print_locs=(_arg0); end
+
+ # Print a string with indentation and `\n` at the end.
+ #
+ # source://rbi//lib/rbi/printer.rb#72
+ 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#58
+ 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#65
+ sig { params(string: T.nilable(::String)).void }
+ def printt(string = T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/printer.rb#83
+ sig { override.params(node: T.nilable(::RBI::Node)).void }
+ def visit(node); end
+
+ # source://rbi//lib/rbi/printer.rb#90
+ sig { override.params(nodes: T::Array[::RBI::Node]).void }
+ def visit_all(nodes); end
+
+ # source://rbi//lib/rbi/printer.rb#78
+ sig { params(file: ::RBI::File).void }
+ def visit_file(file); end
+end
+
+# source://rbi//lib/rbi/model.rb#909
+class RBI::Private < ::RBI::Visibility
+ # source://rbi//lib/rbi/model.rb#919
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Private).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#893
+class RBI::Protected < ::RBI::Visibility
+ # source://rbi//lib/rbi/model.rb#903
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Protected).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#877
+class RBI::Public < ::RBI::Visibility
+ # source://rbi//lib/rbi/model.rb#887
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Public).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#579
+class RBI::ReqParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#590
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::ReqParam).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#596
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+end
+
+# source://rbi//lib/rbi/model.rb#1378
+class RBI::RequiresAncestor < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1391
+ 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/printer.rb#870
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/index.rb#163
+ sig { override.returns(T::Array[::String]) }
+ def index_ids; end
+
+ # source://rbi//lib/rbi/model.rb#1382
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/model.rb#1397
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#628
+class RBI::RestParam < ::RBI::Param
+ # source://rbi//lib/rbi/model.rb#639
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::RestParam).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#650
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#483
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#488
+ sig { override.params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # source://rbi//lib/rbi/model.rb#645
+ 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/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
+
+# source://rbi//lib/rbi/rewriters/group_nodes.rb#6
+class RBI::Rewriters::GroupNodes < ::RBI::Visitor
+ # source://rbi//lib/rbi/rewriters/group_nodes.rb#10
+ sig { override.params(node: T.nilable(::RBI::Node)).void }
+ def visit(node); end
+end
+
+# Merge two RBI trees together
+#
+# Be this `Tree`:
+# ~~~rb
+# class Foo
+# attr_accessor :a
+# def m; end
+# C = 10
+# end
+# ~~~
+#
+# Merged with this one:
+# ~~~rb
+# class Foo
+# attr_reader :a
+# def m(x); end
+# C = 10
+# end
+# ~~~
+#
+# Compatible definitions are merged together while incompatible definitions are moved into a `ConflictTree`:
+# ~~~rb
+# class Foo
+# <<<<<<< left
+# attr_accessor :a
+# def m; end
+# =======
+# attr_reader :a
+# def m(x); end
+# >>>>>>> right
+# 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,
+ right: ::RBI::Tree,
+ left_name: ::String,
+ right_name: ::String,
+ keep: ::RBI::Rewriters::Merge::Keep
+ ).returns(::RBI::MergeTree)
+ end
+ def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+ end
+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.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# Merge adjacent conflict trees
+#
+# Transform this:
+# ~~~rb
+# class Foo
+# <<<<<<< left
+# def m1; end
+# =======
+# def m1(a); end
+# >>>>>>> right
+# <<<<<<< left
+# def m2(a); end
+# =======
+# def m2; end
+# >>>>>>> right
+# end
+# ~~~
+#
+# Into this:
+# ~~~rb
+# class Foo
+# <<<<<<< left
+# def m1; end
+# def m2(a); end
+# =======
+# def m1(a); end
+# def m2; 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
+ 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,
+ left_name: ::String,
+ right_name: ::String,
+ keep: ::RBI::Rewriters::Merge::Keep
+ ).void
+ 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
+ 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
+
+# Remove all definitions existing in the index from the current tree
+#
+# Let's create an `Index` from two different `Tree`s:
+# ~~~rb
+# tree1 = Parse.parse_string(<<~RBI)
+# class Foo
+# def foo; end
+# end
+# RBI
+#
+# tree2 = Parse.parse_string(<<~RBI)
+# FOO = 10
+# RBI
+#
+# index = Index.index(tree1, tree2)
+# ~~~
+#
+# We can use `RemoveKnownDefinitions` to remove the definitions found in the `index` from the `Tree` to clean:
+# ~~~rb
+# tree_to_clean = Parser.parse_string(<<~RBI)
+# class Foo
+# def foo; end
+# def bar; end
+# end
+# FOO = 10
+# BAR = 42
+# RBI
+#
+# cleaned_tree, operations = RemoveKnownDefinitions.remove(tree_to_clean, index)
+#
+# assert_equal(<<~RBI, cleaned_tree)
+# class Foo
+# def bar; end
+# end
+# BAR = 42
+# RBI
+#
+# assert_equal(<<~OPERATIONS, operations.join("\n"))
+# Deleted ::Foo#foo at -:2:2-2-16 (duplicate from -:2:2-2:16)
+# 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,
+ index: ::RBI::Index
+ ).returns([::RBI::Tree, T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]])
+ end
+ def remove(tree, index); end
+ 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.11162/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
+
+# Scopes
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://rbi//lib/rbi/model.rb#176
+class RBI::Scope < ::RBI::Tree
+ include ::RBI::Indexable
+
+ abstract!
+
+ # source://rbi//lib/rbi/printer.rb#242
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # Duplicate `self` scope without its body
+ #
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#356
+ sig { returns(T.self_type) }
+ def dup_empty; end
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/model.rb#182
+ 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/printer.rb#256
+ sig { params(v: ::RBI::Printer).void }
+ def print_body(v); end
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/printer.rb#253
+ sig { abstract.params(v: ::RBI::Printer).void }
+ def print_header(v); end
+
+ # source://rbi//lib/rbi/model.rb#185
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# A conflict between two scope headers
+#
+# Is rendered as a merge conflict between `left` and` right` for scope definitions:
+# ~~~rb
+# <<<<<<< left
+# class Foo
+# =======
+# module Foo
+# >>>>>>> right
+# def m1; end
+# end
+# ~~~
+#
+# source://rbi//lib/rbi/rewriters/merge_trees.rb#628
+class RBI::ScopeConflict < ::RBI::Tree
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#642
+ 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#651
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#632
+ sig { returns(::RBI::Scope) }
+ def left; end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#667
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # @return [Scope]
+ #
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#632
+ def right; end
+end
+
+# Sends
+#
+# source://rbi//lib/rbi/model.rb#927
+class RBI::Send < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#945
+ sig do
+ params(
+ method: ::String,
+ args: T::Array[::RBI::Arg],
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Send).void)
+ ).void
+ end
+ def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#953
+ sig { params(arg: ::RBI::Arg).void }
+ def <<(arg); end
+
+ # source://rbi//lib/rbi/model.rb#958
+ sig { params(other: T.nilable(::Object)).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#592
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#934
+ sig { returns(T::Array[::RBI::Arg]) }
+ def args; end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#529
+ 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#931
+ sig { returns(::String) }
+ def method; end
+
+ # source://rbi//lib/rbi/model.rb#963
+ sig { returns(::String) }
+ def to_s; end
+end
+
+# Sorbet's sigs
+#
+# source://rbi//lib/rbi/model.rb#1027
+class RBI::Sig < ::RBI::Node
+ # source://rbi//lib/rbi/model.rb#1059
+ sig do
+ params(
+ params: T::Array[::RBI::SigParam],
+ return_type: T.nilable(::String),
+ is_abstract: T::Boolean,
+ is_override: T::Boolean,
+ is_overridable: T::Boolean,
+ is_final: T::Boolean,
+ type_params: T::Array[::String],
+ checked: T.nilable(::Symbol),
+ loc: T.nilable(::RBI::Loc),
+ 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
+
+ # source://rbi//lib/rbi/model.rb#1084
+ sig { params(param: ::RBI::SigParam).void }
+ def <<(param); end
+
+ # source://rbi//lib/rbi/model.rb#1089
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#633
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#1043
+ sig { returns(T.nilable(::Symbol)) }
+ def checked; end
+
+ # @return [Symbol, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#1043
+ def checked=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#656
+ sig { returns(T::Boolean) }
+ def inline_params?; end
+
+ # source://rbi//lib/rbi/model.rb#1037
+ sig { returns(T::Boolean) }
+ def is_abstract; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_abstract=(_arg0); end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_final; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_final=(_arg0); end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_overridable; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_overridable=(_arg0); end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_override; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#1037
+ def is_override=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#651
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # source://rbi//lib/rbi/model.rb#1031
+ sig { returns(T::Array[::RBI::SigParam]) }
+ def params; end
+
+ # source://rbi//lib/rbi/model.rb#1034
+ sig { returns(T.nilable(::String)) }
+ def return_type; end
+
+ # @return [String, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#1034
+ def return_type=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#1040
+ sig { returns(T::Array[::String]) }
+ def type_params; end
+
+ private
+
+ # source://rbi//lib/rbi/printer.rb#698
+ sig { params(v: ::RBI::Printer).void }
+ def print_as_block(v); end
+
+ # source://rbi//lib/rbi/printer.rb#674
+ sig { params(v: ::RBI::Printer).void }
+ def print_as_line(v); end
+
+ # source://rbi//lib/rbi/printer.rb#663
+ sig { returns(T::Array[::String]) }
+ def sig_modifiers; end
+end
+
+# source://rbi//lib/rbi/model.rb#1098
+class RBI::SigParam < ::RBI::NodeWithComments
+ # source://rbi//lib/rbi/model.rb#1113
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::SigParam).void)
+ ).void
+ end
+ def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#1121
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#751
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#764
+ sig { returns(T::Array[::String]) }
+ def comments_lines; end
+
+ # source://rbi//lib/rbi/model.rb#1102
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/printer.rb#756
+ sig { params(v: ::RBI::Printer, last: T::Boolean).void }
+ def print_comment_leading_space(v, last:); end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#1102
+ def type; end
+end
+
+# source://rbi//lib/rbi/model.rb#251
+class RBI::SingletonClass < ::RBI::Scope
+ # source://rbi//lib/rbi/model.rb#261
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::SingletonClass).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#267
+ sig { override.returns(::String) }
+ def fully_qualified_name; end
+
+ # source://rbi//lib/rbi/printer.rb#321
+ sig { override.params(v: ::RBI::Printer).void }
+ def print_header(v); end
+end
+
+# source://rbi//lib/rbi/model.rb#272
+class RBI::Struct < ::RBI::Scope
+ # source://rbi//lib/rbi/model.rb#294
+ sig do
+ params(
+ name: ::String,
+ members: T::Array[::Symbol],
+ keyword_init: T::Boolean,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(struct: ::RBI::Struct).void)
+ ).void
+ 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#394
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#303
+ sig { override.returns(::String) }
+ def fully_qualified_name; end
+
+ # source://rbi//lib/rbi/model.rb#282
+ sig { returns(T::Boolean) }
+ def keyword_init; end
+
+ # @return [Boolean]
+ #
+ # source://rbi//lib/rbi/model.rb#282
+ def keyword_init=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#279
+ sig { returns(T::Array[::Symbol]) }
+ def members; end
+
+ # @return [Array]
+ #
+ # source://rbi//lib/rbi/model.rb#279
+ def members=(_arg0); end
+
+ # source://rbi//lib/rbi/model.rb#276
+ sig { returns(::String) }
+ def name; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#276
+ def name=(_arg0); end
+
+ # source://rbi//lib/rbi/printer.rb#300
+ sig { override.params(v: ::RBI::Printer).void }
+ def print_header(v); end
+end
+
+# Sorbet's T::Enum
+#
+# source://rbi//lib/rbi/model.rb#1239
+class RBI::TEnum < ::RBI::Class
+ # source://rbi//lib/rbi/model.rb#1250
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(klass: ::RBI::TEnum).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#1256
+class RBI::TEnumBlock < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1270
+ 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#1282
+ sig { params(name: ::String).void }
+ def <<(name); end
+
+ # source://rbi//lib/rbi/printer.rb#795
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#1277
+ sig { returns(T::Boolean) }
+ def empty?; 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#556
+ sig { override.params(other: ::RBI::Node).void }
+ def merge_with(other); end
+
+ # source://rbi//lib/rbi/model.rb#1260
+ sig { returns(T::Array[::String]) }
+ def names; end
+
+ # source://rbi//lib/rbi/model.rb#1287
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# Sorbet's T::Struct
+#
+# source://rbi//lib/rbi/model.rb#1128
+class RBI::TStruct < ::RBI::Class
+ # source://rbi//lib/rbi/model.rb#1139
+ sig do
+ params(
+ name: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(klass: ::RBI::TStruct).void)
+ ).void
+ end
+ def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+# source://rbi//lib/rbi/model.rb#1177
+class RBI::TStructConst < ::RBI::TStructField
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1190
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ default: T.nilable(::String),
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::TStructConst).void)
+ ).void
+ 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#547
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#1196
+ 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#1202
+ 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#1145
+class RBI::TStructField < ::RBI::NodeWithComments
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#1166
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ default: T.nilable(::String),
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment]
+ ).void
+ end
+ def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+ # source://rbi//lib/rbi/printer.rb#773
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/rewriters/merge_trees.rb#538
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#1155
+ sig { returns(T.nilable(::String)) }
+ def default; end
+
+ # @return [String, nil]
+ #
+ # source://rbi//lib/rbi/model.rb#1155
+ def default=(_arg0); end
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/model.rb#1174
+ sig { abstract.returns(T::Array[::String]) }
+ def fully_qualified_names; end
+
+ # source://rbi//lib/rbi/model.rb#1152
+ sig { returns(::String) }
+ def name; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#1152
+ def name=(_arg0); end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#1152
+ def type; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#1152
+ def type=(_arg0); end
+end
+
+# source://rbi//lib/rbi/model.rb#1207
+class RBI::TStructProp < ::RBI::TStructField
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1220
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ default: T.nilable(::String),
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::TStructProp).void)
+ ).void
+ 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#570
+ sig { override.params(other: ::RBI::Node).returns(T::Boolean) }
+ def compatible_with?(other); end
+
+ # source://rbi//lib/rbi/model.rb#1226
+ 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#1232
+ sig { override.returns(::String) }
+ def to_s; end
+end
+
+# source://rbi//lib/rbi/model.rb#106
+class RBI::Tree < ::RBI::NodeWithComments
+ # source://rbi//lib/rbi/model.rb#119
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/model.rb#126
+ sig { params(node: ::RBI::Node).void }
+ def <<(node); end
+
+ # source://rbi//lib/rbi/printer.rb#226
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); 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.11.14/lib/tapioca/rbi_ext/model.rb#38
+ sig do
+ params(
+ name: ::String,
+ superclass_name: T.nilable(::String),
+ block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
+ ).returns(::RBI::Scope)
+ end
+ def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#45
+ sig { params(name: ::String, value: ::String).void }
+ def create_constant(name, value:); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#55
+ sig { params(name: ::String).void }
+ def create_extend(name); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#50
+ sig { params(name: ::String).void }
+ def create_include(name); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#89
+ sig do
+ params(
+ name: ::String,
+ parameters: T::Array[::RBI::TypedParam],
+ return_type: ::String,
+ class_method: T::Boolean,
+ visibility: ::RBI::Visibility,
+ comments: T::Array[::RBI::Comment]
+ ).void
+ 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)); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#60
+ sig { params(name: ::String).void }
+ def create_mixes_in_class_methods(name); end
+
+ # source://tapioca/0.11.14/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.11.14/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.11.14/lib/tapioca/rbi_ext/model.rb#74
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).void
+ 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#132
+ sig { returns(T::Boolean) }
+ def empty?; end
+
+ # source://rbi//lib/rbi/rewriters/group_nodes.rb#38
+ 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,
+ left_name: ::String,
+ right_name: ::String,
+ keep: ::RBI::Rewriters::Merge::Keep
+ ).returns(::RBI::MergeTree)
+ 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
+
+ # source://rbi//lib/rbi/rewriters/nest_singleton_methods.rb#36
+ sig { void }
+ def nest_singleton_methods!; end
+
+ # source://rbi//lib/rbi/model.rb#110
+ sig { returns(T::Array[::RBI::Node]) }
+ def nodes; end
+
+ # source://rbi//lib/rbi/printer.rb#233
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # source://rbi//lib/rbi/rewriters/sort_nodes.rb#119
+ sig { void }
+ def sort_nodes!; end
+
+ private
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#116
+ sig { params(node: ::RBI::Node).returns(::RBI::Node) }
+ def create_node(node); end
+
+ # source://tapioca/0.11.14/lib/tapioca/rbi_ext/model.rb#111
+ sig { returns(T::Hash[::String, ::RBI::Node]) }
+ def nodes_cache; end
+end
+
+# source://rbi//lib/rbi/model.rb#1320
+class RBI::TypeMember < ::RBI::NodeWithComments
+ include ::RBI::Indexable
+
+ # source://rbi//lib/rbi/model.rb#1335
+ sig do
+ params(
+ name: ::String,
+ value: ::String,
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::TypeMember).void)
+ ).void
+ end
+ def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi//lib/rbi/printer.rb#812
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#1343
+ 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#1324
+ sig { returns(::String) }
+ def name; end
+
+ # source://rbi//lib/rbi/model.rb#1350
+ sig { override.returns(::String) }
+ def to_s; end
+
+ # @return [String]
+ #
+ # source://rbi//lib/rbi/model.rb#1324
+ def value; end
+end
+
+# source://rbi//lib/rbi/parser.rb#20
+class RBI::UnexpectedParserError < ::StandardError
+ # 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#841
+class RBI::Visibility < ::RBI::NodeWithComments
+ abstract!
+
+ # source://rbi//lib/rbi/model.rb#851
+ 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#857
+ sig { params(other: ::RBI::Visibility).returns(T::Boolean) }
+ def ==(other); end
+
+ # source://rbi//lib/rbi/printer.rb#579
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/model.rb#872
+ sig { returns(T::Boolean) }
+ def private?; end
+
+ # source://rbi//lib/rbi/model.rb#867
+ sig { returns(T::Boolean) }
+ def protected?; end
+
+ # source://rbi//lib/rbi/model.rb#862
+ sig { returns(T::Boolean) }
+ def public?; end
+
+ # source://rbi//lib/rbi/model.rb#848
+ 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/printer.rb#848
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi//lib/rbi/printer.rb#861
+ sig { override.returns(T::Boolean) }
+ def oneline?; 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#5
+class RBI::Visitor
+ abstract!
+
+ # @abstract
+ #
+ # source://rbi//lib/rbi/visitor.rb#12
+ sig { abstract.params(node: T.nilable(::RBI::Node)).void }
+ def visit(node); end
+
+ # source://rbi//lib/rbi/visitor.rb#15
+ sig { params(nodes: T::Array[::RBI::Node]).void }
+ def visit_all(nodes); end
+end
diff --git a/2023/sorbet/rbi/gems/sorbet-struct-comparable@1.3.0.rbi b/2023/sorbet/rbi/gems/sorbet-struct-comparable@1.3.0.rbi
new file mode 100644
index 0000000..9ad7473
--- /dev/null
+++ b/2023/sorbet/rbi/gems/sorbet-struct-comparable@1.3.0.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `sorbet-struct-comparable` gem.
+# Please instead update this file by running `bin/tapioca gem sorbet-struct-comparable`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem
diff --git a/2023/sorbet/rbi/gems/spoom@1.2.4.rbi b/2023/sorbet/rbi/gems/spoom@1.2.4.rbi
new file mode 100644
index 0000000..197151a
--- /dev/null
+++ b/2023/sorbet/rbi/gems/spoom@1.2.4.rbi
@@ -0,0 +1,3777 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `spoom` gem.
+# Please instead update this file by running `bin/tapioca gem spoom`.
+
+# source://spoom//lib/spoom.rb#7
+module Spoom; end
+
+# source://spoom//lib/spoom/cli/helper.rb#9
+module Spoom::Cli; end
+
+# source://spoom//lib/spoom/cli/bump.rb#9
+class Spoom::Cli::Bump < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ # source://spoom//lib/spoom/cli/bump.rb#49
+ sig { params(directory: ::String).void }
+ def bump(directory = T.unsafe(nil)); end
+
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/bump.rb#170
+ def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/bump.rb#192
+ def undo_changes(files, from_strictness); end
+end
+
+# source://spoom//lib/spoom/cli/config.rb#9
+class Spoom::Cli::Config < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/config.rb#15
+ def show; end
+end
+
+# source://spoom//lib/spoom/cli/coverage.rb#9
+class Spoom::Cli::Coverage < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ # source://spoom//lib/spoom/cli/coverage.rb#198
+ def bundle_install(path, sha); end
+
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#210
+ def message_no_data(file); end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#173
+ def open(file = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#189
+ def parse_time(string, option); end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#142
+ def report; end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#20
+ def snapshot; end
+
+ # source://spoom//lib/spoom/cli/coverage.rb#42
+ def timeline; end
+end
+
+# source://spoom//lib/spoom/cli/coverage.rb#12
+Spoom::Cli::Coverage::DATA_DIR = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/helper.rb#10
+module Spoom::Cli::Helper
+ include ::Spoom::Colorize
+
+ requires_ancestor { Thor }
+
+ # source://spoom//lib/spoom/cli/helper.rb#119
+ sig { params(string: ::String).returns(::String) }
+ def blue(string); end
+
+ # Is the `--color` option true?
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#83
+ sig { returns(T::Boolean) }
+ def color?; end
+
+ # Colorize a string if `color?`
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#112
+ sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+ def colorize(string, *color); end
+
+ # Returns the context at `--path` (by default the current working directory)
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#51
+ sig { returns(::Spoom::Context) }
+ def context; end
+
+ # Raise if `spoom` is not ran inside a context with a `sorbet/config` file
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#57
+ sig { returns(::Spoom::Context) }
+ def context_requiring_sorbet!; end
+
+ # source://spoom//lib/spoom/cli/helper.rb#124
+ sig { params(string: ::String).returns(::String) }
+ def cyan(string); end
+
+ # Return the path specified through `--path`
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#72
+ sig { returns(::String) }
+ def exec_path; end
+
+ # source://spoom//lib/spoom/cli/helper.rb#129
+ sig { params(string: ::String).returns(::String) }
+ def gray(string); end
+
+ # source://spoom//lib/spoom/cli/helper.rb#134
+ sig { params(string: ::String).returns(::String) }
+ def green(string); end
+
+ # source://spoom//lib/spoom/cli/helper.rb#88
+ sig { params(string: ::String).returns(::String) }
+ def highlight(string); end
+
+ # source://spoom//lib/spoom/cli/helper.rb#139
+ sig { params(string: ::String).returns(::String) }
+ def red(string); end
+
+ # Print `message` on `$stdout`
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#20
+ sig { params(message: ::String).void }
+ def say(message); end
+
+ # Print `message` on `$stderr`
+ #
+ # The message is prefixed by a status (default: `Error`).
+ #
+ # source://spoom//lib/spoom/cli/helper.rb#39
+ sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
+ def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/helper.rb#144
+ sig { params(string: ::String).returns(::String) }
+ def yellow(string); end
+end
+
+# source://spoom//lib/spoom/cli/lsp.rb#10
+class Spoom::Cli::LSP < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#55
+ def defs(file, line, col); end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#65
+ def find(query); end
+
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#41
+ def hover(file, line, col); end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#26
+ def list; end
+
+ # source://spoom//lib/spoom/cli/lsp.rb#114
+ def lsp_client; end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#85
+ def refs(file, line, col); end
+
+ # source://spoom//lib/spoom/cli/lsp.rb#137
+ def run(&block); end
+
+ # source://spoom//lib/spoom/cli/lsp.rb#16
+ def show; end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#95
+ def sigs(file, line, col); end
+
+ # source://spoom//lib/spoom/cli/lsp.rb#129
+ def symbol_printer; end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#75
+ def symbols(file); end
+
+ # source://spoom//lib/spoom/cli/lsp.rb#162
+ def to_uri(path); end
+
+ # TODO: options, filter, limit, kind etc.. filter rbi
+ #
+ # source://spoom//lib/spoom/cli/lsp.rb#105
+ def types(file, line, col); end
+end
+
+# source://spoom//lib/spoom/cli.rb#16
+class Spoom::Cli::Main < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ # source://spoom//lib/spoom/cli.rb#61
+ def __print_version; end
+
+ # source://thor/1.3.0/lib/thor.rb#334
+ def bump(*args); end
+
+ # source://thor/1.3.0/lib/thor.rb#334
+ def config(*args); end
+
+ # source://thor/1.3.0/lib/thor.rb#334
+ def coverage(*args); end
+
+ # source://spoom//lib/spoom/cli.rb#43
+ def files; end
+
+ # source://thor/1.3.0/lib/thor.rb#334
+ def lsp(*args); end
+
+ # source://thor/1.3.0/lib/thor.rb#334
+ def tc(*args); end
+
+ class << self
+ # @return [Boolean]
+ #
+ # source://spoom//lib/spoom/cli.rb#68
+ def exit_on_failure?; end
+ end
+end
+
+# source://spoom//lib/spoom/cli/run.rb#6
+class Spoom::Cli::Run < ::Thor
+ include ::Spoom::Colorize
+ include ::Spoom::Cli::Helper
+
+ # source://spoom//lib/spoom/cli/run.rb#131
+ def colorize_message(message); end
+
+ # source://spoom//lib/spoom/cli/run.rb#122
+ def format_error(error, format); end
+
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/cli/run.rb#26
+ def tc(*paths_to_select); end
+end
+
+# source://spoom//lib/spoom/cli/run.rb#15
+Spoom::Cli::Run::DEFAULT_FORMAT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/run.rb#11
+Spoom::Cli::Run::SORT_CODE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/cli/run.rb#13
+Spoom::Cli::Run::SORT_ENUM = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/cli/run.rb#12
+Spoom::Cli::Run::SORT_LOC = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/colors.rb#5
+class Spoom::Color < ::T::Enum
+ enums do
+ CLEAR = new
+ BOLD = new
+ BLACK = new
+ RED = new
+ GREEN = new
+ YELLOW = new
+ BLUE = new
+ MAGENTA = new
+ CYAN = new
+ WHITE = new
+ LIGHT_BLACK = new
+ LIGHT_RED = new
+ LIGHT_GREEN = new
+ LIGHT_YELLOW = new
+ LIGHT_BLUE = new
+ LIGHT_MAGENTA = new
+ LIGHT_CYAN = new
+ LIGHT_WHITE = new
+ end
+
+ # source://spoom//lib/spoom/colors.rb#32
+ sig { returns(::String) }
+ def ansi_code; end
+end
+
+# source://spoom//lib/spoom/colors.rb#37
+module Spoom::Colorize
+ # source://spoom//lib/spoom/colors.rb#41
+ sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+ def set_color(string, *color); end
+end
+
+# An abstraction to a Ruby project context
+#
+# A context maps to a directory in the file system.
+# It is used to manipulate files and run commands in the context of this directory.
+#
+# source://spoom//lib/spoom/context/bundle.rb#5
+class Spoom::Context
+ include ::Spoom::Context::Bundle
+ include ::Spoom::Context::Exec
+ include ::Spoom::Context::FileSystem
+ include ::Spoom::Context::Git
+ include ::Spoom::Context::Sorbet
+
+ # Create a new context about `absolute_path`
+ #
+ # The directory will not be created if it doesn't exist.
+ # Call `#make!` to create it.
+ #
+ # source://spoom//lib/spoom/context.rb#51
+ sig { params(absolute_path: ::String).void }
+ def initialize(absolute_path); end
+
+ # The absolute path to the directory this context is about
+ #
+ # source://spoom//lib/spoom/context.rb#44
+ sig { returns(::String) }
+ def absolute_path; end
+
+ class << self
+ # Create a new context in the system's temporary directory
+ #
+ # `name` is used as prefix to the temporary directory name.
+ # The directory will be created if it doesn't exist.
+ #
+ # source://spoom//lib/spoom/context.rb#37
+ sig { params(name: T.nilable(::String)).returns(T.attached_class) }
+ def mktmp!(name = T.unsafe(nil)); end
+ end
+end
+
+# Bundle features for a context
+#
+# source://spoom//lib/spoom/context/bundle.rb#7
+module Spoom::Context::Bundle
+ requires_ancestor { Spoom::Context }
+
+ # Run a command with `bundle` in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#33
+ sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def bundle(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # Run a command `bundle exec` in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#46
+ sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def bundle_exec(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # Run `bundle install` in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#40
+ sig { params(version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def bundle_install!(version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # Get `gem` version from the `Gemfile.lock` content
+ #
+ # Returns `nil` if `gem` cannot be found in the Gemfile.
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#62
+ sig { params(gem: ::String).returns(T.nilable(::String)) }
+ def gem_version_from_gemfile_lock(gem); end
+
+ # source://spoom//lib/spoom/context/bundle.rb#51
+ sig { returns(T::Hash[::String, ::Bundler::LazySpecification]) }
+ def gemfile_lock_specs; end
+
+ # Read the contents of the Gemfile in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#15
+ sig { returns(T.nilable(::String)) }
+ def read_gemfile; end
+
+ # Read the contents of the Gemfile.lock in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#21
+ sig { returns(T.nilable(::String)) }
+ def read_gemfile_lock; end
+
+ # Set the `contents` of the Gemfile in this context directory
+ #
+ # source://spoom//lib/spoom/context/bundle.rb#27
+ sig { params(contents: ::String, append: T::Boolean).void }
+ def write_gemfile!(contents, append: T.unsafe(nil)); end
+end
+
+# Execution features for a context
+#
+# source://spoom//lib/spoom/context/exec.rb#27
+module Spoom::Context::Exec
+ requires_ancestor { Spoom::Context }
+
+ # Run a command in this context directory
+ #
+ # source://spoom//lib/spoom/context/exec.rb#35
+ sig { params(command: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def exec(command, capture_err: T.unsafe(nil)); end
+end
+
+# File System features for a context
+#
+# source://spoom//lib/spoom/context/file_system.rb#7
+module Spoom::Context::FileSystem
+ requires_ancestor { Spoom::Context }
+
+ # Returns the absolute path to `relative_path` in the context's directory
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#15
+ sig { params(relative_path: ::String).returns(::String) }
+ def absolute_path_to(relative_path); end
+
+ # source://spoom//lib/spoom/context/file_system.rb#53
+ sig do
+ params(
+ allow_extensions: T::Array[::String],
+ allow_mime_types: T::Array[::String],
+ exclude_patterns: T::Array[::String]
+ ).returns(T::Array[::String])
+ end
+ def collect_files(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+ # Delete this context and its content
+ #
+ # Warning: it will `rm -rf` the context directory on the file system.
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#105
+ sig { void }
+ def destroy!; end
+
+ # Does the context directory at `absolute_path` exist and is a directory?
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#21
+ sig { returns(T::Boolean) }
+ def exist?; end
+
+ # Does `relative_path` point to an existing file in this context directory?
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#65
+ sig { params(relative_path: ::String).returns(T::Boolean) }
+ def file?(relative_path); end
+
+ # List all files in this context matching `pattern`
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#34
+ sig { params(pattern: ::String).returns(T::Array[::String]) }
+ def glob(pattern = T.unsafe(nil)); end
+
+ # List all files at the top level of this context directory
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#42
+ sig { returns(T::Array[::String]) }
+ def list; end
+
+ # Create the context directory at `absolute_path`
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#27
+ sig { void }
+ def mkdir!; end
+
+ # Move the file or directory from `from_relative_path` to `to_relative_path`
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#95
+ sig { params(from_relative_path: ::String, to_relative_path: ::String).void }
+ def move!(from_relative_path, to_relative_path); end
+
+ # Return the contents of the file at `relative_path` in this context directory
+ #
+ # Will raise if the file doesn't exist.
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#73
+ sig { params(relative_path: ::String).returns(::String) }
+ def read(relative_path); end
+
+ # Remove the path at `relative_path` (recursive + force) in this context directory
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#89
+ sig { params(relative_path: ::String).void }
+ def remove!(relative_path); end
+
+ # Write `contents` in the file at `relative_path` in this context directory
+ #
+ # Append to the file if `append` is true.
+ #
+ # source://spoom//lib/spoom/context/file_system.rb#81
+ sig { params(relative_path: ::String, contents: ::String, append: T::Boolean).void }
+ def write!(relative_path, contents = T.unsafe(nil), append: T.unsafe(nil)); end
+end
+
+# Git features for a context
+#
+# source://spoom//lib/spoom/context/git.rb#35
+module Spoom::Context::Git
+ requires_ancestor { Spoom::Context }
+
+ # Run a command prefixed by `git` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#43
+ sig { params(command: ::String).returns(::Spoom::ExecResult) }
+ def git(command); end
+
+ # Run `git checkout` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#62
+ sig { params(ref: ::String).returns(::Spoom::ExecResult) }
+ def git_checkout!(ref: T.unsafe(nil)); end
+
+ # Run `git checkout -b ` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#68
+ sig { params(branch_name: ::String, ref: T.nilable(::String)).returns(::Spoom::ExecResult) }
+ def git_checkout_new_branch!(branch_name, ref: T.unsafe(nil)); end
+
+ # Run `git add . && git commit` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#78
+ sig { params(message: ::String, time: ::Time, allow_empty: T::Boolean).returns(::Spoom::ExecResult) }
+ def git_commit!(message: T.unsafe(nil), time: T.unsafe(nil), allow_empty: T.unsafe(nil)); end
+
+ # Get the current git branch in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#89
+ sig { returns(T.nilable(::String)) }
+ def git_current_branch; end
+
+ # Run `git diff` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#98
+ sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+ def git_diff(*arg); end
+
+ # Run `git init` in this context directory
+ #
+ # Warning: passing a branch will run `git init -b ` which is only available in git 2.28+.
+ # In older versions, use `git_init!` followed by `git("checkout -b ")`.
+ #
+ # source://spoom//lib/spoom/context/git.rb#52
+ sig { params(branch: T.nilable(::String)).returns(::Spoom::ExecResult) }
+ def git_init!(branch: T.unsafe(nil)); end
+
+ # Get the last commit in the currently checked out branch
+ #
+ # source://spoom//lib/spoom/context/git.rb#104
+ sig { params(short_sha: T::Boolean).returns(T.nilable(::Spoom::Git::Commit)) }
+ def git_last_commit(short_sha: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/context/git.rb#115
+ sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+ def git_log(*arg); end
+
+ # Run `git push ` in this context directory
+ #
+ # source://spoom//lib/spoom/context/git.rb#121
+ sig { params(remote: ::String, ref: ::String, force: T::Boolean).returns(::Spoom::ExecResult) }
+ def git_push!(remote, ref, force: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/context/git.rb#126
+ sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+ def git_show(*arg); end
+
+ # Is there uncommited changes in this context directory?
+ #
+ # source://spoom//lib/spoom/context/git.rb#132
+ sig { params(path: ::String).returns(T::Boolean) }
+ def git_workdir_clean?(path: T.unsafe(nil)); end
+end
+
+# Sorbet features for a context
+#
+# source://spoom//lib/spoom/context/sorbet.rb#7
+module Spoom::Context::Sorbet
+ requires_ancestor { Spoom::Context }
+
+ # Does this context has a `sorbet/config` file?
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#119
+ sig { returns(T::Boolean) }
+ def has_sorbet_config?; end
+
+ # Read the strictness sigil from the file at `relative_path` (returns `nil` if no sigil)
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#142
+ sig { params(relative_path: ::String).returns(T.nilable(::String)) }
+ def read_file_strictness(relative_path); end
+
+ # Read the contents of `sorbet/config` in this context directory
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#130
+ sig { returns(::String) }
+ def read_sorbet_config; end
+
+ # source://spoom//lib/spoom/context/sorbet.rb#124
+ sig { returns(::Spoom::Sorbet::Config) }
+ def sorbet_config; end
+
+ # Get the commit introducing the `sorbet/config` file
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#148
+ sig { returns(T.nilable(::Spoom::Git::Commit)) }
+ def sorbet_intro_commit; end
+
+ # Get the commit removing the `sorbet/config` file
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#160
+ sig { returns(T.nilable(::Spoom::Git::Commit)) }
+ def sorbet_removal_commit; end
+
+ # Run `bundle exec srb` in this context directory
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#15
+ sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def srb(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # List all files typechecked by Sorbet from its `config`
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#65
+ sig { params(with_config: T.nilable(::Spoom::Sorbet::Config), include_rbis: T::Boolean).returns(T::Array[::String]) }
+ def srb_files(with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+ # List all files typechecked by Sorbet from its `config` that matches `strictness`
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#104
+ sig do
+ params(
+ strictness: ::String,
+ with_config: T.nilable(::Spoom::Sorbet::Config),
+ include_rbis: T::Boolean
+ ).returns(T::Array[::String])
+ end
+ def srb_files_with_strictness(strictness, with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/context/sorbet.rb#45
+ sig do
+ params(
+ arg: ::String,
+ sorbet_bin: T.nilable(::String),
+ capture_err: T::Boolean
+ ).returns(T.nilable(T::Hash[::String, ::Integer]))
+ end
+ def srb_metrics(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/context/sorbet.rb#33
+ sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+ def srb_tc(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/context/sorbet.rb#110
+ sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(T.nilable(::String)) }
+ def srb_version(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+ # Set the `contents` of `sorbet/config` in this context directory
+ #
+ # source://spoom//lib/spoom/context/sorbet.rb#136
+ sig { params(contents: ::String, append: T::Boolean).void }
+ def write_sorbet_config!(contents, append: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#5
+module Spoom::Coverage
+ class << self
+ # source://spoom//lib/spoom/coverage.rb#103
+ sig { params(context: ::Spoom::Context).returns(::Spoom::FileTree) }
+ def file_tree(context); end
+
+ # source://spoom//lib/spoom/coverage.rb#83
+ sig do
+ params(
+ context: ::Spoom::Context,
+ snapshots: T::Array[::Spoom::Coverage::Snapshot],
+ palette: ::Spoom::Coverage::D3::ColorPalette
+ ).returns(::Spoom::Coverage::Report)
+ end
+ def report(context, snapshots, palette:); end
+
+ # source://spoom//lib/spoom/coverage.rb#16
+ sig do
+ params(
+ context: ::Spoom::Context,
+ rbi: T::Boolean,
+ sorbet_bin: T.nilable(::String)
+ ).returns(::Spoom::Coverage::Snapshot)
+ end
+ def snapshot(context, rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+ end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#88
+module Spoom::Coverage::Cards; end
+
+# source://spoom//lib/spoom/coverage/report.rb#89
+class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template
+ # source://spoom//lib/spoom/coverage/report.rb#98
+ sig { params(template: ::String, title: T.nilable(::String), body: T.nilable(::String)).void }
+ def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end
+
+ # @return [String, nil]
+ #
+ # source://spoom//lib/spoom/coverage/report.rb#95
+ def body; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#95
+ sig { returns(T.nilable(::String)) }
+ def title; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#92
+Spoom::Coverage::Cards::Card::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#105
+class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/report.rb#112
+ sig { void }
+ def initialize; end
+
+ # @abstract
+ #
+ # source://spoom//lib/spoom/coverage/report.rb#120
+ sig { abstract.returns(::String) }
+ def erb; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#115
+ sig { override.returns(::String) }
+ def html; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#153
+class Spoom::Coverage::Cards::Map < ::Spoom::Coverage::Cards::Card
+ # source://spoom//lib/spoom/coverage/report.rb#164
+ sig do
+ params(
+ file_tree: ::Spoom::FileTree,
+ nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+ nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+ title: ::String
+ ).void
+ end
+ def initialize(file_tree:, nodes_strictnesses:, nodes_strictness_scores:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#123
+class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card
+ # source://spoom//lib/spoom/coverage/report.rb#132
+ sig { params(snapshot: ::Spoom::Coverage::Snapshot, title: ::String).void }
+ def initialize(snapshot:, title: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/report.rb#143
+ sig { returns(::Spoom::Coverage::D3::Pie::Calls) }
+ def pie_calls; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#138
+ sig { returns(::Spoom::Coverage::D3::Pie::Sigils) }
+ def pie_sigils; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#148
+ sig { returns(::Spoom::Coverage::D3::Pie::Sigs) }
+ def pie_sigs; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#129
+ sig { returns(::Spoom::Coverage::Snapshot) }
+ def snapshot; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#126
+Spoom::Coverage::Cards::Snapshot::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/report.rb#240
+class Spoom::Coverage::Cards::SorbetIntro < ::Spoom::Coverage::Cards::Erb
+ # source://spoom//lib/spoom/coverage/report.rb#244
+ sig { params(sorbet_intro_commit: T.nilable(::String), sorbet_intro_date: T.nilable(::Time)).void }
+ def initialize(sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/report.rb#250
+ sig { override.returns(::String) }
+ def erb; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#177
+class Spoom::Coverage::Cards::Timeline < ::Spoom::Coverage::Cards::Card
+ # source://spoom//lib/spoom/coverage/report.rb#181
+ sig { params(title: ::String, timeline: ::Spoom::Coverage::D3::Timeline).void }
+ def initialize(title:, timeline:); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#194
+class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#198
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#212
+class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#216
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#230
+class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#234
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#185
+class Spoom::Coverage::Cards::Timeline::Sigils < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#189
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#203
+class Spoom::Coverage::Cards::Timeline::Sigs < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#207
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#221
+class Spoom::Coverage::Cards::Timeline::Versions < ::Spoom::Coverage::Cards::Timeline
+ # source://spoom//lib/spoom/coverage/report.rb#225
+ sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+ def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+# source://spoom//lib/spoom/coverage/d3/base.rb#6
+module Spoom::Coverage::D3
+ class << self
+ # source://spoom//lib/spoom/coverage/d3.rb#61
+ sig { params(palette: ::Spoom::Coverage::D3::ColorPalette).returns(::String) }
+ def header_script(palette); end
+
+ # source://spoom//lib/spoom/coverage/d3.rb#21
+ sig { returns(::String) }
+ def header_style; end
+ end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/base.rb#7
+class Spoom::Coverage::D3::Base
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/d3/base.rb#17
+ sig { params(id: ::String, data: T.untyped).void }
+ def initialize(id, data); end
+
+ # source://spoom//lib/spoom/coverage/d3/base.rb#37
+ sig { returns(::String) }
+ def html; end
+
+ # source://spoom//lib/spoom/coverage/d3/base.rb#14
+ sig { returns(::String) }
+ def id; end
+
+ # @abstract
+ #
+ # source://spoom//lib/spoom/coverage/d3/base.rb#50
+ sig { abstract.returns(::String) }
+ def script; end
+
+ # source://spoom//lib/spoom/coverage/d3/base.rb#45
+ sig { returns(::String) }
+ def tooltip; end
+
+ class << self
+ # source://spoom//lib/spoom/coverage/d3/base.rb#31
+ sig { returns(::String) }
+ def header_script; end
+
+ # source://spoom//lib/spoom/coverage/d3/base.rb#26
+ sig { returns(::String) }
+ def header_style; end
+ end
+end
+
+# source://spoom//lib/spoom/coverage/d3.rb#12
+Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#11
+Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#14
+Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#15
+Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3.rb#13
+Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/d3/circle_map.rb#9
+class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
+ # source://spoom//lib/spoom/coverage/d3/circle_map.rb#59
+ sig { override.returns(::String) }
+ def script; end
+
+ class << self
+ # source://spoom//lib/spoom/coverage/d3/circle_map.rb#40
+ sig { returns(::String) }
+ def header_script; end
+
+ # source://spoom//lib/spoom/coverage/d3/circle_map.rb#14
+ sig { returns(::String) }
+ def header_style; end
+ end
+end
+
+# source://spoom//lib/spoom/coverage/d3/circle_map.rb#148
+class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap
+ # source://spoom//lib/spoom/coverage/d3/circle_map.rb#159
+ sig do
+ params(
+ id: ::String,
+ file_tree: ::Spoom::FileTree,
+ nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+ nodes_scores: T::Hash[::Spoom::FileTree::Node, ::Float]
+ ).void
+ end
+ def initialize(id, file_tree, nodes_strictnesses, nodes_scores); end
+
+ # source://spoom//lib/spoom/coverage/d3/circle_map.rb#166
+ sig { params(node: ::Spoom::FileTree::Node).returns(T::Hash[::Symbol, T.untyped]) }
+ def tree_node_to_json(node); end
+end
+
+# source://spoom//lib/spoom/coverage/d3.rb#103
+class Spoom::Coverage::D3::ColorPalette < ::T::Struct
+ prop :ignore, ::String
+ prop :false, ::String
+ prop :true, ::String
+ prop :strict, ::String
+ prop :strong, ::String
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/pie.rb#9
+class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#16
+ sig { params(id: ::String, title: ::String, data: T.untyped).void }
+ def initialize(id, title, data); end
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#56
+ sig { override.returns(::String) }
+ def script; end
+
+ class << self
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#43
+ sig { returns(::String) }
+ def header_script; end
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#25
+ sig { returns(::String) }
+ def header_style; end
+ end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#141
+class Spoom::Coverage::D3::Pie::Calls < ::Spoom::Coverage::D3::Pie
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#145
+ sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+ def initialize(id, title, snapshot); end
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#150
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#123
+class Spoom::Coverage::D3::Pie::Sigils < ::Spoom::Coverage::D3::Pie
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#127
+ sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+ def initialize(id, title, snapshot); end
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#132
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/pie.rb#159
+class Spoom::Coverage::D3::Pie::Sigs < ::Spoom::Coverage::D3::Pie
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#163
+ sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+ def initialize(id, title, snapshot); end
+
+ # source://spoom//lib/spoom/coverage/d3/pie.rb#172
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#9
+class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#16
+ sig { params(id: ::String, data: T.untyped, keys: T::Array[::String]).void }
+ def initialize(id, data, keys); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#187
+ sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+ def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#203
+ sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+ def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+ # @abstract
+ #
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#126
+ sig { abstract.returns(::String) }
+ def plot; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#217
+ sig { params(y: ::String).returns(::String) }
+ def points(y:); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#101
+ sig { override.returns(::String) }
+ def script; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#129
+ sig { returns(::String) }
+ def x_scale; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#145
+ sig { returns(::String) }
+ def x_ticks; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#158
+ sig { params(min: ::String, max: ::String, ticks: ::String).returns(::String) }
+ def y_scale(min:, max:, ticks:); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#174
+ sig { params(ticks: ::String, format: ::String, padding: ::Integer).returns(::String) }
+ def y_ticks(ticks:, format:, padding:); end
+
+ class << self
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#79
+ sig { returns(::String) }
+ def header_script; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#25
+ sig { returns(::String) }
+ def header_style; end
+ end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#448
+class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::Stacked
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#452
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#466
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#505
+class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#509
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#577
+ sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+ def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#617
+ sig { override.returns(::String) }
+ def plot; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#537
+ sig { override.returns(::String) }
+ def script; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#523
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#282
+class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#286
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#311
+ sig { override.returns(::String) }
+ def plot; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#298
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#421
+class Spoom::Coverage::D3::Timeline::Sigils < ::Spoom::Coverage::D3::Timeline::Stacked
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#425
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#439
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#475
+class Spoom::Coverage::D3::Timeline::Sigs < ::Spoom::Coverage::D3::Timeline::Stacked
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#479
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#496
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#329
+class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#388
+ sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+ def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#377
+ sig { override.returns(::String) }
+ def plot; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#336
+ sig { override.returns(::String) }
+ def script; end
+end
+
+# source://spoom//lib/spoom/coverage/d3/timeline.rb#232
+class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#236
+ sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+ def initialize(id, snapshots); end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#263
+ sig { override.returns(::String) }
+ def plot; end
+
+ # source://spoom//lib/spoom/coverage/d3/timeline.rb#249
+ sig { override.returns(::String) }
+ def tooltip; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#38
+class Spoom::Coverage::Page < ::Spoom::Coverage::Template
+ abstract!
+
+ # source://spoom//lib/spoom/coverage/report.rb#53
+ sig { params(title: ::String, palette: ::Spoom::Coverage::D3::ColorPalette, template: ::String).void }
+ def initialize(title:, palette:, template: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/report.rb#75
+ sig { returns(::String) }
+ def body_html; end
+
+ # @abstract
+ #
+ # source://spoom//lib/spoom/coverage/report.rb#80
+ sig { abstract.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+ def cards; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#83
+ sig { returns(::String) }
+ def footer_html; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#70
+ sig { returns(::String) }
+ def header_html; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#65
+ sig { returns(::String) }
+ def header_script; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#60
+ sig { returns(::String) }
+ def header_style; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#50
+ sig { returns(::Spoom::Coverage::D3::ColorPalette) }
+ def palette; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#47
+ sig { returns(::String) }
+ def title; end
+end
+
+# source://spoom//lib/spoom/coverage/report.rb#44
+Spoom::Coverage::Page::TEMPLATE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/coverage/report.rb#261
+class Spoom::Coverage::Report < ::Spoom::Coverage::Page
+ # source://spoom//lib/spoom/coverage/report.rb#276
+ sig do
+ params(
+ project_name: ::String,
+ palette: ::Spoom::Coverage::D3::ColorPalette,
+ snapshots: T::Array[::Spoom::Coverage::Snapshot],
+ file_tree: ::Spoom::FileTree,
+ nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+ nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+ sorbet_intro_commit: T.nilable(::String),
+ sorbet_intro_date: T.nilable(::Time)
+ ).void
+ end
+ def initialize(project_name:, palette:, snapshots:, file_tree:, nodes_strictnesses:, nodes_strictness_scores:, sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/report.rb#308
+ sig { override.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+ def cards; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#297
+ sig { override.returns(::String) }
+ def header_html; end
+end
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#6
+class Spoom::Coverage::Snapshot < ::T::Struct
+ prop :timestamp, ::Integer, default: T.unsafe(nil)
+ prop :version_static, T.nilable(::String), default: T.unsafe(nil)
+ prop :version_runtime, T.nilable(::String), default: T.unsafe(nil)
+ prop :duration, ::Integer, default: T.unsafe(nil)
+ prop :commit_sha, T.nilable(::String), default: T.unsafe(nil)
+ prop :commit_timestamp, T.nilable(::Integer), default: T.unsafe(nil)
+ prop :files, ::Integer, default: T.unsafe(nil)
+ prop :rbi_files, ::Integer, default: T.unsafe(nil)
+ prop :modules, ::Integer, default: T.unsafe(nil)
+ prop :classes, ::Integer, default: T.unsafe(nil)
+ prop :singleton_classes, ::Integer, default: T.unsafe(nil)
+ prop :methods_without_sig, ::Integer, default: T.unsafe(nil)
+ prop :methods_with_sig, ::Integer, default: T.unsafe(nil)
+ prop :calls_untyped, ::Integer, default: T.unsafe(nil)
+ prop :calls_typed, ::Integer, default: T.unsafe(nil)
+ prop :sigils, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+ prop :methods_with_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+ prop :methods_without_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+ prop :sigils_excluding_rbis, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+
+ # source://spoom//lib/spoom/coverage/snapshot.rb#33
+ sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+ def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/coverage/snapshot.rb#39
+ sig { params(arg: T.untyped).returns(::String) }
+ def to_json(*arg); end
+
+ class << self
+ # source://spoom//lib/spoom/coverage/snapshot.rb#47
+ sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) }
+ def from_json(json); end
+
+ # source://spoom//lib/spoom/coverage/snapshot.rb#52
+ sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) }
+ def from_obj(obj); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# The strictness name as found in the Sorbet metrics file
+#
+# source://spoom//lib/spoom/coverage/snapshot.rb#30
+Spoom::Coverage::Snapshot::STRICTNESSES = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/coverage/snapshot.rb#95
+class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer
+ # source://spoom//lib/spoom/coverage/snapshot.rb#99
+ sig { params(snapshot: ::Spoom::Coverage::Snapshot).void }
+ def print_snapshot(snapshot); end
+
+ private
+
+ # source://spoom//lib/spoom/coverage/snapshot.rb#158
+ sig { params(value: T.nilable(::Integer), total: T.nilable(::Integer)).returns(::String) }
+ def percent(value, total); end
+
+ # source://spoom//lib/spoom/coverage/snapshot.rb#147
+ sig { params(hash: T::Hash[::String, ::Integer], total: ::Integer).void }
+ def print_map(hash, total); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/coverage/report.rb#10
+class Spoom::Coverage::Template
+ abstract!
+
+ # Create a new template from an Erb file path
+ #
+ # source://spoom//lib/spoom/coverage/report.rb#18
+ sig { params(template: ::String).void }
+ def initialize(template:); end
+
+ # source://spoom//lib/spoom/coverage/report.rb#23
+ sig { returns(::String) }
+ def erb; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#33
+ sig { returns(::Binding) }
+ def get_binding; end
+
+ # source://spoom//lib/spoom/coverage/report.rb#28
+ sig { returns(::String) }
+ def html; end
+end
+
+# source://spoom//lib/spoom/deadcode/erb.rb#27
+module Spoom::Deadcode
+ class << self
+ # source://spoom//lib/spoom/deadcode.rb#51
+ sig do
+ params(
+ index: ::Spoom::Deadcode::Index,
+ erb: ::String,
+ file: ::String,
+ plugins: T::Array[::Spoom::Deadcode::Plugins::Base]
+ ).void
+ end
+ def index_erb(index, erb, file:, plugins: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/deadcode.rb#40
+ sig do
+ params(
+ index: ::Spoom::Deadcode::Index,
+ ruby: ::String,
+ file: ::String,
+ plugins: T::Array[::Spoom::Deadcode::Plugins::Base]
+ ).void
+ end
+ def index_ruby(index, ruby, file:, plugins: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/deadcode/plugins.rb#74
+ sig { params(context: ::Spoom::Context).returns(T::Array[::Spoom::Deadcode::Plugins::Base]) }
+ def load_custom_plugins(context); end
+
+ # source://spoom//lib/spoom/deadcode/plugins.rb#60
+ sig { params(context: ::Spoom::Context).returns(T::Array[::Spoom::Deadcode::Plugins::Base]) }
+ def plugins_from_gemfile_lock(context); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#25
+Spoom::Deadcode::DEFAULT_CUSTOM_PLUGINS_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#27
+Spoom::Deadcode::DEFAULT_PLUGINS = T.let(T.unsafe(nil), Set)
+
+# A definition is a class, module, method, constant, etc. being defined in the code
+#
+# source://spoom//lib/spoom/deadcode/definition.rb#7
+class Spoom::Deadcode::Definition < ::T::Struct
+ const :kind, ::Spoom::Deadcode::Definition::Kind
+ const :name, ::String
+ const :full_name, ::String
+ const :location, ::Spoom::Deadcode::Location
+ const :status, ::Spoom::Deadcode::Definition::Status, default: T.unsafe(nil)
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#78
+ sig { void }
+ def alive!; end
+
+ # Status
+ #
+ # source://spoom//lib/spoom/deadcode/definition.rb#73
+ sig { returns(T::Boolean) }
+ def alive?; end
+
+ # Kind
+ #
+ # source://spoom//lib/spoom/deadcode/definition.rb#41
+ sig { returns(T::Boolean) }
+ def attr_reader?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#46
+ sig { returns(T::Boolean) }
+ def attr_writer?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#51
+ sig { returns(T::Boolean) }
+ def class?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#56
+ sig { returns(T::Boolean) }
+ def constant?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#83
+ sig { returns(T::Boolean) }
+ def dead?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#93
+ sig { void }
+ def ignored!; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#88
+ sig { returns(T::Boolean) }
+ def ignored?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#61
+ sig { returns(T::Boolean) }
+ def method?; end
+
+ # source://spoom//lib/spoom/deadcode/definition.rb#66
+ sig { returns(T::Boolean) }
+ def module?; end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/definition.rb#10
+class Spoom::Deadcode::Definition::Kind < ::T::Enum
+ enums do
+ AttrReader = new
+ AttrWriter = new
+ Class = new
+ Constant = new
+ Method = new
+ Module = new
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/definition.rb#21
+class Spoom::Deadcode::Definition::Status < ::T::Enum
+ enums do
+ ALIVE = new
+ DEAD = new
+ IGNORED = new
+ end
+end
+
+# Custom engine to handle ERB templates as used by Rails
+#
+# source://spoom//lib/spoom/deadcode/erb.rb#29
+class Spoom::Deadcode::ERB < ::Erubi::Engine
+ # source://spoom//lib/spoom/deadcode/erb.rb#33
+ sig { params(input: T.untyped, properties: T.untyped).void }
+ def initialize(input, properties = T.unsafe(nil)); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/erb.rb#83
+ sig { override.params(code: T.untyped).void }
+ def add_code(code); end
+
+ # source://spoom//lib/spoom/deadcode/erb.rb#66
+ sig { override.params(indicator: T.untyped, code: T.untyped).void }
+ def add_expression(indicator, code); end
+
+ # source://spoom//lib/spoom/deadcode/erb.rb#89
+ sig { override.params(_: T.untyped).void }
+ def add_postamble(_); end
+
+ # source://spoom//lib/spoom/deadcode/erb.rb#48
+ sig { override.params(text: T.untyped).void }
+ def add_text(text); end
+
+ # source://spoom//lib/spoom/deadcode/erb.rb#95
+ sig { params(src: T.untyped).void }
+ def flush_newline_if_pending(src); end
+end
+
+# source://spoom//lib/spoom/deadcode/erb.rb#63
+Spoom::Deadcode::ERB::BLOCK_EXPR = T.let(T.unsafe(nil), Regexp)
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/deadcode.rb#20
+class Spoom::Deadcode::Error < ::Spoom::Error
+ abstract!
+
+ # source://spoom//lib/spoom/deadcode.rb#27
+ sig { params(message: ::String, parent: ::Exception).void }
+ def initialize(message, parent:); end
+end
+
+# source://spoom//lib/spoom/deadcode/index.rb#6
+class Spoom::Deadcode::Index
+ # source://spoom//lib/spoom/deadcode/index.rb#16
+ sig { void }
+ def initialize; end
+
+ # source://spoom//lib/spoom/deadcode/index.rb#51
+ sig { returns(T::Array[::Spoom::Deadcode::Definition]) }
+ def all_definitions; end
+
+ # source://spoom//lib/spoom/deadcode/index.rb#56
+ sig { returns(T::Array[::Spoom::Deadcode::Reference]) }
+ def all_references; end
+
+ # Indexing
+ #
+ # source://spoom//lib/spoom/deadcode/index.rb#24
+ sig { params(definition: ::Spoom::Deadcode::Definition).void }
+ def define(definition); end
+
+ # source://spoom//lib/spoom/deadcode/index.rb#10
+ sig { returns(T::Hash[::String, T::Array[::Spoom::Deadcode::Definition]]) }
+ def definitions; end
+
+ # Utils
+ #
+ # source://spoom//lib/spoom/deadcode/index.rb#46
+ sig { params(name: ::String).returns(T::Array[::Spoom::Deadcode::Definition]) }
+ def definitions_for_name(name); end
+
+ # Mark all definitions having a reference of the same name as `alive`
+ #
+ # To be called once all the files have been indexed and all the definitions and references discovered.
+ #
+ # source://spoom//lib/spoom/deadcode/index.rb#37
+ sig { void }
+ def finalize!; end
+
+ # source://spoom//lib/spoom/deadcode/index.rb#29
+ sig { params(reference: ::Spoom::Deadcode::Reference).void }
+ def reference(reference); end
+
+ # source://spoom//lib/spoom/deadcode/index.rb#13
+ sig { returns(T::Hash[::String, T::Array[::Spoom::Deadcode::Reference]]) }
+ def references; end
+end
+
+# source://spoom//lib/spoom/deadcode/indexer.rb#6
+class Spoom::Deadcode::Indexer < ::SyntaxTree::Visitor
+ # source://spoom//lib/spoom/deadcode/indexer.rb#16
+ sig do
+ params(
+ path: ::String,
+ source: ::String,
+ index: ::Spoom::Deadcode::Index,
+ plugins: T::Array[::Spoom::Deadcode::Plugins::Base]
+ ).void
+ end
+ def initialize(path, source, index, plugins: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#459
+ sig do
+ params(
+ node: T.nilable(T.any(::SyntaxTree::ArgParen, ::SyntaxTree::Args, ::SyntaxTree::ArgsForward))
+ ).returns(T::Array[::SyntaxTree::Node])
+ end
+ def call_args(node); end
+
+ # Context
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#367
+ sig { returns(::SyntaxTree::Node) }
+ def current_node; end
+
+ # Definition indexing
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#281
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_attr_reader(name, full_name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#293
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_attr_writer(name, full_name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#305
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_class(name, full_name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#317
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_constant(name, full_name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#329
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_method(name, full_name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#341
+ sig { params(name: ::String, full_name: ::String, node: ::SyntaxTree::Node).void }
+ def define_module(name, full_name, node); end
+
+ # @return [String]
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#10
+ def file_name; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#13
+ sig { returns(::Spoom::Deadcode::Index) }
+ def index; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#426
+ sig { returns(T.nilable(::String)) }
+ def last_sig; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#386
+ sig { returns(T.nilable(::SyntaxTree::BlockNode)) }
+ def nesting_block; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#391
+ sig { returns(T.nilable(::SyntaxTree::MethodAddBlock)) }
+ def nesting_block_call; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#396
+ sig { returns(T.nilable(::String)) }
+ def nesting_block_call_name; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#381
+ sig { returns(T.nilable(::SyntaxTree::ClassDeclaration)) }
+ def nesting_class; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#410
+ sig { returns(T.nilable(::String)) }
+ def nesting_class_name; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#418
+ sig { returns(T.nilable(::String)) }
+ def nesting_class_superclass_name; end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#372
+ sig { type_parameters(:N).params(type: T::Class[T.type_parameter(:N)]).returns(T.nilable(T.type_parameter(:N))) }
+ def nesting_node(type); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#445
+ sig { params(node: ::SyntaxTree::Node).returns(::Spoom::Deadcode::Location) }
+ def node_location(node); end
+
+ # Node utils
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#435
+ sig { params(node: T.any(::Symbol, ::SyntaxTree::Node)).returns(::String) }
+ def node_string(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#10
+ sig { returns(::String) }
+ def path; end
+
+ # Reference indexing
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#355
+ sig { params(name: ::String, node: ::SyntaxTree::Node).void }
+ def reference_constant(name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#360
+ sig { params(name: ::String, node: ::SyntaxTree::Node).void }
+ def reference_method(name, node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#450
+ sig { params(node: ::SyntaxTree::Node).returns(::String) }
+ def symbol_string(node); end
+
+ # Visit
+ #
+ # source://spoom//lib/spoom/deadcode/indexer.rb#35
+ sig { override.params(node: T.nilable(::SyntaxTree::Node)).void }
+ def visit(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#45
+ sig { override.params(node: ::SyntaxTree::AliasNode).void }
+ def visit_alias(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#50
+ sig { override.params(node: ::SyntaxTree::ARef).void }
+ def visit_aref(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#57
+ sig { override.params(node: ::SyntaxTree::ARefField).void }
+ def visit_aref_field(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#64
+ sig { override.params(node: ::SyntaxTree::ArgBlock).void }
+ def visit_arg_block(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#78
+ sig { override.params(node: ::SyntaxTree::Binary).void }
+ def visit_binary(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#94
+ sig { override.params(node: ::SyntaxTree::CallNode).void }
+ def visit_call(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#106
+ sig { override.params(node: ::SyntaxTree::ClassDeclaration).void }
+ def visit_class(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#119
+ sig { override.params(node: ::SyntaxTree::Command).void }
+ def visit_command(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#131
+ sig { override.params(node: ::SyntaxTree::CommandCall).void }
+ def visit_command_call(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#144
+ sig { override.params(node: ::SyntaxTree::Const).void }
+ def visit_const(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#149
+ sig { override.params(node: ::SyntaxTree::ConstPathField).void }
+ def visit_const_path_field(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#159
+ sig { override.params(node: ::SyntaxTree::DefNode).void }
+ def visit_def(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#167
+ sig { override.params(node: ::SyntaxTree::Field).void }
+ def visit_field(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#183
+ sig { override.params(node: ::SyntaxTree::ModuleDeclaration).void }
+ def visit_module(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#195
+ sig { override.params(node: ::SyntaxTree::OpAssign).void }
+ def visit_opassign(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#204
+ sig { params(send: ::Spoom::Deadcode::Send).void }
+ def visit_send(send); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#243
+ sig { override.params(node: ::SyntaxTree::SymbolLiteral).void }
+ def visit_symbol_literal(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#252
+ sig { override.params(node: ::SyntaxTree::TopConstField).void }
+ def visit_top_const_field(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#257
+ sig { override.params(node: ::SyntaxTree::VarField).void }
+ def visit_var_field(node); end
+
+ # source://spoom//lib/spoom/deadcode/indexer.rb#274
+ sig { override.params(node: ::SyntaxTree::VCall).void }
+ def visit_vcall(node); end
+end
+
+# source://spoom//lib/spoom/deadcode.rb#34
+class Spoom::Deadcode::IndexerError < ::Spoom::Deadcode::Error; end
+
+# source://spoom//lib/spoom/deadcode/location.rb#6
+class Spoom::Deadcode::Location
+ include ::Comparable
+
+ # source://spoom//lib/spoom/deadcode/location.rb#54
+ sig do
+ params(
+ file: ::String,
+ start_line: ::Integer,
+ start_column: ::Integer,
+ end_line: ::Integer,
+ end_column: ::Integer
+ ).void
+ end
+ def initialize(file, start_line, start_column, end_line, end_column); end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#74
+ sig { override.params(other: ::BasicObject).returns(T.nilable(::Integer)) }
+ def <=>(other); end
+
+ # @return [Integer]
+ #
+ # source://spoom//lib/spoom/deadcode/location.rb#43
+ def end_column; end
+
+ # @return [Integer]
+ #
+ # source://spoom//lib/spoom/deadcode/location.rb#43
+ def end_line; end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#40
+ sig { returns(::String) }
+ def file; end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#63
+ sig { params(other: ::Spoom::Deadcode::Location).returns(T::Boolean) }
+ def include?(other); end
+
+ # @return [Integer]
+ #
+ # source://spoom//lib/spoom/deadcode/location.rb#43
+ def start_column; end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#43
+ sig { returns(::Integer) }
+ def start_line; end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#81
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # @raise [LocationError]
+ #
+ # source://spoom//lib/spoom/deadcode/location.rb#17
+ sig { params(location_string: ::String).returns(::Spoom::Deadcode::Location) }
+ def from_string(location_string); end
+
+ # source://spoom//lib/spoom/deadcode/location.rb#34
+ sig { params(file: ::String, location: ::SyntaxTree::Location).returns(::Spoom::Deadcode::Location) }
+ def from_syntax_tree(file, location); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/location.rb#11
+class Spoom::Deadcode::Location::LocationError < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/deadcode/plugins.rb#35
+Spoom::Deadcode::PLUGINS_FOR_GEM = T.let(T.unsafe(nil), Hash)
+
+# source://spoom//lib/spoom/deadcode.rb#33
+class Spoom::Deadcode::ParserError < ::Spoom::Deadcode::Error; end
+
+# source://spoom//lib/spoom/deadcode/plugins/base.rb#8
+module Spoom::Deadcode::Plugins; end
+
+# source://spoom//lib/spoom/deadcode/plugins/action_mailer.rb#7
+class Spoom::Deadcode::Plugins::ActionMailer < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/action_mailer.rb#11
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#7
+class Spoom::Deadcode::Plugins::ActionPack < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#31
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#36
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/actionpack.rb#10
+Spoom::Deadcode::Plugins::ActionPack::CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_job.rb#7
+class Spoom::Deadcode::Plugins::ActiveJob < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_model.rb#7
+class Spoom::Deadcode::Plugins::ActiveModel < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/active_model.rb#14
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#7
+class Spoom::Deadcode::Plugins::ActiveRecord < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/active_record.rb#74
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#64
+Spoom::Deadcode::Plugins::ActiveRecord::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#20
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACKS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_record.rb#49
+Spoom::Deadcode::Plugins::ActiveRecord::CRUD_METHODS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/deadcode/plugins/active_support.rb#7
+class Spoom::Deadcode::Plugins::ActiveSupport < ::Spoom::Deadcode::Plugins::Base; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/deadcode/plugins/base.rb#9
+class Spoom::Deadcode::Plugins::Base
+ abstract!
+
+ # Do not override this method, use `on_define_accessor` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#150
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def internal_on_define_accessor(indexer, definition); end
+
+ # Do not override this method, use `on_define_class` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#174
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def internal_on_define_class(indexer, definition); end
+
+ # Do not override this method, use `on_define_constant` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#204
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def internal_on_define_constant(indexer, definition); end
+
+ # Do not override this method, use `on_define_method` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#232
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def internal_on_define_method(indexer, definition); end
+
+ # Do not override this method, use `on_define_module` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#258
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def internal_on_define_module(indexer, definition); end
+
+ # Do not override this method, use `on_send` instead.
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#284
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def internal_on_send(indexer, send); end
+
+ # Called when an accessor is defined.
+ #
+ # Will be called when the indexer processes a `attr_reader`, `attr_writer` or `attr_accessor` node.
+ # Note that when this method is called, the definition for the node has already been added to the index.
+ # It is still possible to ignore it from the plugin:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_define_accessor(indexer, definition)
+ # definition.ignored! if definition.name == "foo"
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#144
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_accessor(indexer, definition); end
+
+ # Called when a class is defined.
+ #
+ # Will be called when the indexer processes a `class` node.
+ # Note that when this method is called, the definition for the node has already been added to the index.
+ # It is still possible to ignore it from the plugin:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_define_class(indexer, definition)
+ # definition.ignored! if definition.name == "Foo"
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#168
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_class(indexer, definition); end
+
+ # Called when a constant is defined.
+ #
+ # Will be called when the indexer processes a `CONST =` node.
+ # Note that when this method is called, the definition for the node has already been added to the index.
+ # It is still possible to ignore it from the plugin:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_define_constant(indexer, definition)
+ # definition.ignored! if definition.name == "FOO"
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#198
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_constant(indexer, definition); end
+
+ # Called when a method is defined.
+ #
+ # Will be called when the indexer processes a `def` or `defs` node.
+ # Note that when this method is called, the definition for the node has already been added to the index.
+ # It is still possible to ignore it from the plugin:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_define_method(indexer, definition)
+ # super # So the `ignore_method_names` DSL is still applied
+ #
+ # definition.ignored! if definition.name == "foo"
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#226
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+
+ # Called when a module is defined.
+ #
+ # Will be called when the indexer processes a `module` node.
+ # Note that when this method is called, the definition for the node has already been added to the index.
+ # It is still possible to ignore it from the plugin:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_define_module(indexer, definition)
+ # definition.ignored! if definition.name == "Foo"
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#252
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_module(indexer, definition); end
+
+ # Called when a send is being processed
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # def on_send(indexer, send)
+ # return unless send.name == "dsl_method"
+ # return if send.args.empty?
+ #
+ # method_name = indexer.node_string(send.args.first).delete_prefix(":")
+ # indexer.reference_method(method_name, send.node)
+ # end
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#278
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+
+ private
+
+ # Plugin utils
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#339
+ sig { params(name: ::String).returns(::String) }
+ def camelize(name); end
+
+ # DSL support
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#293
+ sig { params(name: T.nilable(::String)).returns(T::Boolean) }
+ def ignored_class_name?(name); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#307
+ sig { params(name: ::String).returns(T::Boolean) }
+ def ignored_constant_name?(name); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#312
+ sig { params(name: ::String).returns(T::Boolean) }
+ def ignored_method_name?(name); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#317
+ sig { params(name: ::String).returns(T::Boolean) }
+ def ignored_module_name?(name); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#322
+ sig { params(name: ::String, names_variable: ::Symbol, patterns_variable: ::Symbol).returns(T::Boolean) }
+ def ignored_name?(name, names_variable, patterns_variable); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#300
+ sig { params(superclass_name: T.nilable(::String)).returns(T::Boolean) }
+ def ignored_subclass?(superclass_name); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#327
+ sig { params(const: ::Symbol).returns(T::Set[::String]) }
+ def names(const); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#332
+ sig { params(const: ::Symbol).returns(T::Array[::Regexp]) }
+ def patterns(const); end
+
+ class << self
+ # Mark classes directly subclassing a class matching `names` as ignored.
+ #
+ # Names can be either strings or regexps:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # ignore_classes_inheriting_from(
+ # "Foo",
+ # "Bar",
+ # /Baz.*/,
+ # )
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#52
+ sig { params(names: T.any(::Regexp, ::String)).void }
+ def ignore_classes_inheriting_from(*names); end
+
+ # Mark classes matching `names` as ignored.
+ #
+ # Names can be either strings or regexps:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # ignore_class_names(
+ # "Foo",
+ # "Bar",
+ # /Baz.*/,
+ # )
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#34
+ sig { params(names: T.any(::Regexp, ::String)).void }
+ def ignore_classes_named(*names); end
+
+ # Mark constants matching `names` as ignored.
+ #
+ # Names can be either strings or regexps:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # ignore_class_names(
+ # "FOO",
+ # "BAR",
+ # /BAZ.*/,
+ # )
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#70
+ sig { params(names: T.any(::Regexp, ::String)).void }
+ def ignore_constants_named(*names); end
+
+ # Mark methods matching `names` as ignored.
+ #
+ # Names can be either strings or regexps:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # ignore_method_names(
+ # "foo",
+ # "bar",
+ # /baz.*/,
+ # )
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#88
+ sig { params(names: T.any(::Regexp, ::String)).void }
+ def ignore_methods_named(*names); end
+
+ # Mark modules matching `names` as ignored.
+ #
+ # Names can be either strings or regexps:
+ #
+ # ~~~rb
+ # class MyPlugin < Spoom::Deadcode::Plugins::Base
+ # ignore_class_names(
+ # "Foo",
+ # "Bar",
+ # /Baz.*/,
+ # )
+ # end
+ # ~~~
+ #
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#106
+ sig { params(names: T.any(::Regexp, ::String)).void }
+ def ignore_modules_named(*names); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/base.rb#113
+ sig do
+ params(
+ names: T::Array[T.any(::Regexp, ::String)],
+ names_variable: ::Symbol,
+ patterns_variable: ::Symbol
+ ).void
+ end
+ def save_names_and_patterns(names, names_variable, patterns_variable); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/graphql.rb#7
+class Spoom::Deadcode::Plugins::GraphQL < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/graphql.rb#28
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/minitest.rb#7
+class Spoom::Deadcode::Plugins::Minitest < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/minitest.rb#22
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#7
+class Spoom::Deadcode::Plugins::Namespaces < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#11
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_class(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#16
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_module(indexer, definition); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/namespaces.rb#23
+ sig { params(indexer: ::Spoom::Deadcode::Indexer).returns(T::Boolean) }
+ def used_as_namespace?(indexer); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rspec.rb#7
+class Spoom::Deadcode::Plugins::RSpec < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/rails.rb#7
+class Spoom::Deadcode::Plugins::Rails < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/rails.rb#13
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_class(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/rails.rb#18
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_module(indexer, definition); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/rails.rb#25
+ sig { params(indexer: ::Spoom::Deadcode::Indexer).returns(T::Boolean) }
+ def file_is_helper?(indexer); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rake.rb#7
+class Spoom::Deadcode::Plugins::Rake < ::Spoom::Deadcode::Plugins::Base; end
+
+# source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#7
+class Spoom::Deadcode::Plugins::Rubocop < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#18
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_constant(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#23
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#30
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).returns(T::Boolean) }
+ def rubocop_constant?(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#35
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).returns(T::Boolean) }
+ def rubocop_method?(indexer, definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/rubocop.rb#10
+Spoom::Deadcode::Plugins::Rubocop::RUBOCOP_CONSTANTS = T.let(T.unsafe(nil), Set)
+
+# source://spoom//lib/spoom/deadcode/plugins/ruby.rb#7
+class Spoom::Deadcode::Plugins::Ruby < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/ruby.rb#24
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send).void }
+ def on_send(indexer, send); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/ruby.rb#50
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, send: ::Spoom::Deadcode::Send, node: ::SyntaxTree::Node).void }
+ def reference_symbol_as_constant(indexer, send, node); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#7
+class Spoom::Deadcode::Plugins::Sorbet < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#11
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_constant(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#16
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#40
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).returns(T::Boolean) }
+ def sorbet_enum_constant?(indexer, definition); end
+
+ # source://spoom//lib/spoom/deadcode/plugins/sorbet.rb#23
+ sig { params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).returns(T::Boolean) }
+ def sorbet_type_member?(indexer, definition); end
+end
+
+# source://spoom//lib/spoom/deadcode/plugins/thor.rb#7
+class Spoom::Deadcode::Plugins::Thor < ::Spoom::Deadcode::Plugins::Base
+ # source://spoom//lib/spoom/deadcode/plugins/thor.rb#13
+ sig { override.params(indexer: ::Spoom::Deadcode::Indexer, definition: ::Spoom::Deadcode::Definition).void }
+ def on_define_method(indexer, definition); end
+end
+
+# A reference is a call to a method or a constant
+#
+# source://spoom//lib/spoom/deadcode/reference.rb#7
+class Spoom::Deadcode::Reference < ::T::Struct
+ const :kind, ::Spoom::Deadcode::Reference::Kind
+ const :name, ::String
+ const :location, ::Spoom::Deadcode::Location
+
+ # Kind
+ #
+ # source://spoom//lib/spoom/deadcode/reference.rb#24
+ sig { returns(T::Boolean) }
+ def constant?; end
+
+ # source://spoom//lib/spoom/deadcode/reference.rb#29
+ sig { returns(T::Boolean) }
+ def method?; end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/reference.rb#10
+class Spoom::Deadcode::Reference::Kind < ::T::Enum
+ enums do
+ Constant = new
+ Method = new
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#6
+class Spoom::Deadcode::Remover
+ # source://spoom//lib/spoom/deadcode/remover.rb#12
+ sig { params(context: ::Spoom::Context).void }
+ def initialize(context); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#17
+ sig { params(kind: ::Spoom::Deadcode::Definition::Kind, location: ::Spoom::Deadcode::Location).void }
+ def remove_location(kind, location); end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#9
+class Spoom::Deadcode::Remover::Error < ::Spoom::Error; end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#348
+class Spoom::Deadcode::Remover::NodeContext
+ # source://spoom//lib/spoom/deadcode/remover.rb#358
+ sig { params(source: ::String, node: ::SyntaxTree::Node, nesting: T::Array[::SyntaxTree::Node]).void }
+ def initialize(source, node, nesting); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#467
+ sig { returns(T::Array[::SyntaxTree::Node]) }
+ def attached_comments_and_sigs; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#480
+ sig { returns(T.nilable(::SyntaxTree::MethodAddBlock)) }
+ def attached_sig; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#460
+ sig { params(comment: ::SyntaxTree::Node, node: ::SyntaxTree::Node).returns(T::Boolean) }
+ def comment_for_node?(comment, node); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#355
+ sig { returns(T::Array[::SyntaxTree::Node]) }
+ def nesting; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/deadcode/remover.rb#355
+ def nesting=(_arg0); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#407
+ sig { returns(T.nilable(::SyntaxTree::Node)) }
+ def next_node; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#397
+ sig { returns(T::Array[::SyntaxTree::Node]) }
+ def next_nodes; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#352
+ sig { returns(::SyntaxTree::Node) }
+ def node; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#495
+ sig { params(node: T.any(::Symbol, ::SyntaxTree::Node)).returns(::String) }
+ def node_string(node); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#373
+ sig { returns(::Spoom::Deadcode::Remover::NodeContext) }
+ def parent_context; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#365
+ sig { returns(::SyntaxTree::Node) }
+ def parent_node; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#392
+ sig { returns(T.nilable(::SyntaxTree::Node)) }
+ def previous_node; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#382
+ sig { returns(T::Array[::SyntaxTree::Node]) }
+ def previous_nodes; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#412
+ sig { returns(T.nilable(::Spoom::Deadcode::Remover::NodeContext)) }
+ def sclass_context; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#451
+ sig { params(node: T.nilable(::SyntaxTree::Node)).returns(T::Boolean) }
+ def sorbet_extend_sig?(node); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#438
+ sig { params(node: T.nilable(::SyntaxTree::Node)).returns(T::Boolean) }
+ def sorbet_signature?(node); end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#505
+class Spoom::Deadcode::Remover::NodeFinder < ::SyntaxTree::Visitor
+ # source://spoom//lib/spoom/deadcode/remover.rb#554
+ sig { params(location: ::Spoom::Deadcode::Location).void }
+ def initialize(location); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#548
+ sig { returns(T.nilable(::SyntaxTree::Node)) }
+ def node; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#551
+ sig { returns(T::Array[::SyntaxTree::Node]) }
+ def nodes_nesting; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/deadcode/remover.rb#551
+ def nodes_nesting=(_arg0); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#562
+ sig { override.params(node: T.nilable(::SyntaxTree::Node)).void }
+ def visit(node); end
+
+ private
+
+ # TODO: remove once SyntaxTree location are fixed
+ #
+ # source://spoom//lib/spoom/deadcode/remover.rb#601
+ sig { params(node: ::SyntaxTree::Node, nodes: T::Array[::SyntaxTree::Node]).returns(::Spoom::Deadcode::Location) }
+ def location_from_children(node, nodes); end
+
+ # TODO: remove once SyntaxTree location are fixed
+ #
+ # source://spoom//lib/spoom/deadcode/remover.rb#586
+ sig { params(node: ::SyntaxTree::Node).returns(::Spoom::Deadcode::Location) }
+ def location_from_node(node); end
+
+ class << self
+ # source://spoom//lib/spoom/deadcode/remover.rb#512
+ sig do
+ params(
+ source: ::String,
+ location: ::Spoom::Deadcode::Location,
+ kind: ::Spoom::Deadcode::Definition::Kind
+ ).returns(::Spoom::Deadcode::Remover::NodeContext)
+ end
+ def find(source, location, kind); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#531
+ sig { params(node: ::SyntaxTree::Node, kind: ::Spoom::Deadcode::Definition::Kind).returns(T::Boolean) }
+ def node_match_kind?(node, kind); end
+ end
+end
+
+# source://spoom//lib/spoom/deadcode/remover.rb#29
+class Spoom::Deadcode::Remover::NodeRemover
+ # source://spoom//lib/spoom/deadcode/remover.rb#36
+ sig do
+ params(
+ source: ::String,
+ kind: ::Spoom::Deadcode::Definition::Kind,
+ location: ::Spoom::Deadcode::Location
+ ).void
+ end
+ def initialize(source, kind, location); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#46
+ sig { void }
+ def apply_edit; end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#33
+ sig { returns(::String) }
+ def new_source; end
+
+ private
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#142
+ sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+ def delete_attr_accessor(context); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#290
+ sig { params(start_char: ::Integer, end_char: ::Integer).void }
+ def delete_chars(start_char, end_char); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#69
+ sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+ def delete_constant_assignment(context); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#300
+ sig { params(line_number: ::Integer, start_column: ::Integer, end_column: ::Integer).void }
+ def delete_line_part(line_number, start_column, end_column); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#283
+ sig { params(start_line: ::Integer, end_line: ::Integer).void }
+ def delete_lines(start_line, end_line); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#250
+ sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+ def delete_node_and_comments_and_sigs(context); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#207
+ sig do
+ params(
+ node: ::SyntaxTree::Node,
+ send_context: ::Spoom::Deadcode::Remover::NodeContext,
+ was_removed: T::Boolean
+ ).void
+ end
+ def insert_accessor(node, send_context, was_removed:); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#295
+ sig { params(start_char: ::Integer, end_char: ::Integer, replacement: ::String).void }
+ def replace_chars(start_char, end_char, replacement); end
+
+ # source://spoom//lib/spoom/deadcode/remover.rb#315
+ sig do
+ params(
+ node: ::SyntaxTree::MethodAddBlock,
+ name: ::String,
+ kind: ::Spoom::Deadcode::Definition::Kind
+ ).returns(::String)
+ end
+ def transform_sig(node, name:, kind:); end
+end
+
+# An abstraction to simplify handling of SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall and
+# SyntaxTree::VCall nodes.
+#
+# source://spoom//lib/spoom/deadcode/send.rb#8
+class Spoom::Deadcode::Send < ::T::Struct
+ const :node, ::SyntaxTree::Node
+ const :name, ::String
+ const :recv, T.nilable(::SyntaxTree::Node), default: T.unsafe(nil)
+ const :args, T::Array[::SyntaxTree::Node], default: T.unsafe(nil)
+ const :block, T.nilable(::SyntaxTree::Node), default: T.unsafe(nil)
+
+ # source://spoom//lib/spoom/deadcode/send.rb#22
+ sig do
+ type_parameters(:T)
+ .params(
+ arg_type: T::Class[T.type_parameter(:T)],
+ block: T.proc.params(arg: T.type_parameter(:T)).void
+ ).void
+ end
+ def each_arg(arg_type, &block); end
+
+ # source://spoom//lib/spoom/deadcode/send.rb#29
+ sig { params(block: T.proc.params(key: ::SyntaxTree::Node, value: T.nilable(::SyntaxTree::Node)).void).void }
+ def each_arg_assoc(&block); end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom.rb#12
+class Spoom::Error < ::StandardError; end
+
+# source://spoom//lib/spoom/context/exec.rb#5
+class Spoom::ExecResult < ::T::Struct
+ const :out, ::String
+ const :err, T.nilable(::String)
+ const :status, T::Boolean
+ const :exit_code, ::Integer
+
+ # source://spoom//lib/spoom/context/exec.rb#14
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/file_collector.rb#5
+class Spoom::FileCollector
+ # Initialize a new file collector
+ #
+ # If `allow_extensions` is empty, all files are collected.
+ # If `allow_extensions` is an array of extensions, only files with one of these extensions are collected.
+ #
+ # If `allow_mime_types` is empty, all files are collected.
+ # If `allow_mime_types` is an array of mimetypes, files without an extension are collected if their mimetype is in
+ # the list.
+ #
+ # source://spoom//lib/spoom/file_collector.rb#26
+ sig do
+ params(
+ allow_extensions: T::Array[::String],
+ allow_mime_types: T::Array[::String],
+ exclude_patterns: T::Array[::String]
+ ).void
+ end
+ def initialize(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/file_collector.rb#9
+ sig { returns(T::Array[::String]) }
+ def files; end
+
+ # source://spoom//lib/spoom/file_collector.rb#39
+ sig { params(path: ::String).void }
+ def visit_path(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#34
+ sig { params(paths: T::Array[::String]).void }
+ def visit_paths(paths); end
+
+ private
+
+ # source://spoom//lib/spoom/file_collector.rb#56
+ sig { params(path: ::String).returns(::String) }
+ def clean_path(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#73
+ sig { params(path: ::String).returns(T::Boolean) }
+ def excluded_file?(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#88
+ sig { params(path: ::String).returns(T::Boolean) }
+ def excluded_path?(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#97
+ sig { params(path: ::String).returns(T.nilable(::String)) }
+ def mime_type_for(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#68
+ sig { params(path: ::String).void }
+ def visit_directory(path); end
+
+ # source://spoom//lib/spoom/file_collector.rb#61
+ sig { params(path: ::String).void }
+ def visit_file(path); end
+end
+
+# Build a file hierarchy from a set of file paths.
+#
+# source://spoom//lib/spoom/file_tree.rb#6
+class Spoom::FileTree
+ # source://spoom//lib/spoom/file_tree.rb#10
+ sig { params(paths: T::Enumerable[::String]).void }
+ def initialize(paths = T.unsafe(nil)); end
+
+ # Add a `path` to the tree
+ #
+ # This will create all nodes until the root of `path`.
+ #
+ # source://spoom//lib/spoom/file_tree.rb#25
+ sig { params(path: ::String).returns(::Spoom::FileTree::Node) }
+ def add_path(path); end
+
+ # Add all `paths` to the tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#17
+ sig { params(paths: T::Enumerable[::String]).void }
+ def add_paths(paths); end
+
+ # All the nodes in this tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#45
+ sig { returns(T::Array[::Spoom::FileTree::Node]) }
+ def nodes; end
+
+ # Return a map of typing scores for each node in the tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#67
+ sig { params(context: ::Spoom::Context).returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+ def nodes_strictness_scores(context); end
+
+ # Return a map of strictnesses for each node in the tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#59
+ sig { params(context: ::Spoom::Context).returns(T::Hash[::Spoom::FileTree::Node, T.nilable(::String)]) }
+ def nodes_strictnesses(context); end
+
+ # All the paths in this tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#53
+ sig { returns(T::Array[::String]) }
+ def paths; end
+
+ # Return a map of typing scores for each path in the tree
+ #
+ # source://spoom//lib/spoom/file_tree.rb#75
+ sig { params(context: ::Spoom::Context).returns(T::Hash[::String, ::Float]) }
+ def paths_strictness_scores(context); end
+
+ # source://spoom//lib/spoom/file_tree.rb#80
+ sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean).void }
+ def print(out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/file_tree.rb#86
+ sig { params(context: ::Spoom::Context, out: T.any(::IO, ::StringIO), colors: T::Boolean).void }
+ def print_with_strictnesses(context, out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+ # All root nodes
+ #
+ # source://spoom//lib/spoom/file_tree.rb#39
+ sig { returns(T::Array[::Spoom::FileTree::Node]) }
+ def roots; end
+end
+
+# A visitor that collects all the nodes in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#140
+class Spoom::FileTree::CollectNodes < ::Spoom::FileTree::Visitor
+ # source://spoom//lib/spoom/file_tree.rb#147
+ sig { void }
+ def initialize; end
+
+ # source://spoom//lib/spoom/file_tree.rb#144
+ sig { returns(T::Array[::Spoom::FileTree::Node]) }
+ def nodes; end
+
+ # source://spoom//lib/spoom/file_tree.rb#153
+ sig { override.params(node: ::Spoom::FileTree::Node).void }
+ def visit_node(node); end
+end
+
+# A visitor that collects the typing score of each node in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#183
+class Spoom::FileTree::CollectScores < ::Spoom::FileTree::CollectStrictnesses
+ # source://spoom//lib/spoom/file_tree.rb#190
+ sig { params(context: ::Spoom::Context).void }
+ def initialize(context); end
+
+ # source://spoom//lib/spoom/file_tree.rb#187
+ sig { returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+ def scores; end
+
+ # source://spoom//lib/spoom/file_tree.rb#197
+ sig { override.params(node: ::Spoom::FileTree::Node).void }
+ def visit_node(node); end
+
+ private
+
+ # source://spoom//lib/spoom/file_tree.rb#206
+ sig { params(node: ::Spoom::FileTree::Node).returns(::Float) }
+ def node_score(node); end
+
+ # source://spoom//lib/spoom/file_tree.rb#215
+ sig { params(strictness: T.nilable(::String)).returns(::Float) }
+ def strictness_score(strictness); end
+end
+
+# A visitor that collects the strictness of each node in a tree
+#
+# source://spoom//lib/spoom/file_tree.rb#160
+class Spoom::FileTree::CollectStrictnesses < ::Spoom::FileTree::Visitor
+ # source://spoom//lib/spoom/file_tree.rb#167
+ sig { params(context: ::Spoom::Context).void }
+ def initialize(context); end
+
+ # source://spoom//lib/spoom/file_tree.rb#164
+ sig { returns(T::Hash[::Spoom::FileTree::Node, T.nilable(::String)]) }
+ def strictnesses; end
+
+ # source://spoom//lib/spoom/file_tree.rb#174
+ sig { override.params(node: ::Spoom::FileTree::Node).void }
+ def visit_node(node); end
+end
+
+# A node representing either a file or a directory inside a FileTree
+#
+# source://spoom//lib/spoom/file_tree.rb#94
+class Spoom::FileTree::Node < ::T::Struct
+ const :parent, T.nilable(::Spoom::FileTree::Node)
+ const :name, ::String
+ const :children, T::Hash[::String, ::Spoom::FileTree::Node], default: T.unsafe(nil)
+
+ # Full path to this node from root
+ #
+ # source://spoom//lib/spoom/file_tree.rb#108
+ sig { returns(::String) }
+ def path; end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# An internal class used to print a FileTree
+#
+# See `FileTree#print`
+#
+# source://spoom//lib/spoom/file_tree.rb#228
+class Spoom::FileTree::Printer < ::Spoom::FileTree::Visitor
+ # source://spoom//lib/spoom/file_tree.rb#238
+ sig do
+ params(
+ strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+ out: T.any(::IO, ::StringIO),
+ colors: T::Boolean
+ ).void
+ end
+ def initialize(strictnesses, out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/file_tree.rb#246
+ sig { override.params(node: ::Spoom::FileTree::Node).void }
+ def visit_node(node); end
+
+ private
+
+ # source://spoom//lib/spoom/file_tree.rb#271
+ sig { params(strictness: T.nilable(::String)).returns(::Spoom::Color) }
+ def strictness_color(strictness); end
+end
+
+# An abstract visitor for FileTree
+#
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/file_tree.rb#117
+class Spoom::FileTree::Visitor
+ abstract!
+
+ # source://spoom//lib/spoom/file_tree.rb#129
+ sig { params(node: ::Spoom::FileTree::Node).void }
+ def visit_node(node); end
+
+ # source://spoom//lib/spoom/file_tree.rb#134
+ sig { params(nodes: T::Array[::Spoom::FileTree::Node]).void }
+ def visit_nodes(nodes); end
+
+ # source://spoom//lib/spoom/file_tree.rb#124
+ sig { params(tree: ::Spoom::FileTree).void }
+ def visit_tree(tree); end
+end
+
+# source://spoom//lib/spoom/context/git.rb#5
+module Spoom::Git; end
+
+# source://spoom//lib/spoom/context/git.rb#6
+class Spoom::Git::Commit < ::T::Struct
+ const :sha, ::String
+ const :time, ::Time
+
+ # source://spoom//lib/spoom/context/git.rb#27
+ sig { returns(::Integer) }
+ def timestamp; end
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+
+ # Parse a line formated as `%h %at` into a `Commit`
+ #
+ # source://spoom//lib/spoom/context/git.rb#14
+ sig { params(string: ::String).returns(T.nilable(::Spoom::Git::Commit)) }
+ def parse_line(string); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#5
+module Spoom::LSP; end
+
+# source://spoom//lib/spoom/sorbet/lsp.rb#13
+class Spoom::LSP::Client
+ # source://spoom//lib/spoom/sorbet/lsp.rb#17
+ sig { params(sorbet_bin: ::String, sorbet_args: ::String, path: ::String).void }
+ def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#229
+ sig { void }
+ def close; end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#131
+ sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+ def definitions(uri, line, column); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#212
+ sig { params(uri: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+ def document_symbols(uri); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#89
+ sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T.nilable(::Spoom::LSP::Hover)) }
+ def hover(uri, line, column); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#27
+ sig { returns(::Integer) }
+ def next_id; end
+
+ # LSP requests
+ #
+ # @raise [Error::AlreadyOpen]
+ #
+ # source://spoom//lib/spoom/sorbet/lsp.rb#72
+ sig { params(workspace_path: ::String).void }
+ def open(workspace_path); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#54
+ sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+ def read; end
+
+ # @raise [Error::BadHeaders]
+ #
+ # source://spoom//lib/spoom/sorbet/lsp.rb#43
+ sig { returns(T.nilable(::String)) }
+ def read_raw; end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#173
+ sig do
+ params(
+ uri: ::String,
+ line: ::Integer,
+ column: ::Integer,
+ include_decl: T::Boolean
+ ).returns(T::Array[::Spoom::LSP::Location])
+ end
+ def references(uri, line, column, include_decl = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#37
+ sig { params(message: ::Spoom::LSP::Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+ def send(message); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#32
+ sig { params(json_string: ::String).void }
+ def send_raw(json_string); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#110
+ sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::SignatureHelp]) }
+ def signatures(uri, line, column); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#197
+ sig { params(query: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+ def symbols(query); end
+
+ # source://spoom//lib/spoom/sorbet/lsp.rb#152
+ sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+ def type_definitions(uri, line, column); end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#178
+class Spoom::LSP::Diagnostic < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :range, ::Spoom::LSP::Range
+ const :code, ::Integer
+ const :message, ::String
+ const :informations, ::Object
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#202
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#207
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#191
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#212
+class Spoom::LSP::DocumentSymbol < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :name, ::String
+ const :detail, T.nilable(::String)
+ const :kind, ::Integer
+ const :location, T.nilable(::Spoom::LSP::Location)
+ const :range, T.nilable(::Spoom::LSP::Range)
+ const :children, T::Array[::Spoom::LSP::DocumentSymbol]
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#240
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#272
+ sig { returns(::String) }
+ def kind_string; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#267
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#227
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#276
+Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash)
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#6
+class Spoom::LSP::Error < ::StandardError; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#7
+class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#8
+class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#10
+class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#32
+ sig { params(uri: ::String, diagnostics: T::Array[::Spoom::LSP::Diagnostic]).void }
+ def initialize(uri, diagnostics); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#17
+ sig { returns(T::Array[::Spoom::LSP::Diagnostic]) }
+ def diagnostics; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#14
+ sig { returns(::String) }
+ def uri; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#23
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Error::Diagnostics) }
+ def from_json(json); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#19
+class Spoom::LSP::Hover < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :contents, ::String
+ const :range, T.nilable(T::Range[T.untyped])
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#39
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#45
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#30
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#112
+class Spoom::LSP::Location < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :uri, ::String
+ const :range, ::Spoom::LSP::Range
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#132
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#138
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#123
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# A general message as defined by JSON-RPC.
+#
+# The language server protocol always uses `"2.0"` as the `jsonrpc` version.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#12
+class Spoom::LSP::Message
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#16
+ sig { void }
+ def initialize; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#21
+ sig { returns(T::Hash[T.untyped, T.untyped]) }
+ def as_json; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#29
+ sig { params(args: T.untyped).returns(::String) }
+ def to_json(*args); end
+end
+
+# A notification message.
+#
+# A processed notification message must not send a response back. They work like events.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#58
+class Spoom::LSP::Notification < ::Spoom::LSP::Message
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#68
+ sig { params(method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+ def initialize(method, params); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#62
+ sig { returns(::String) }
+ def method; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#65
+ sig { returns(T::Hash[T.untyped, T.untyped]) }
+ def params; end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#50
+class Spoom::LSP::Position < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :line, ::Integer
+ const :char, ::Integer
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#70
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#75
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#61
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# @abstract Subclasses must implement the `abstract` methods below.
+#
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#9
+module Spoom::LSP::PrintableSymbol
+ interface!
+
+ # @abstract
+ #
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#16
+ sig { abstract.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#80
+class Spoom::LSP::Range < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :start, ::Spoom::LSP::Position
+ const :end, ::Spoom::LSP::Position
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#100
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#107
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#91
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# A request message to describe a request between the client and the server.
+#
+# Every processed request must send a response back to the sender of the request.
+#
+# source://spoom//lib/spoom/sorbet/lsp/base.rb#37
+class Spoom::LSP::Request < ::Spoom::LSP::Message
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#47
+ sig { params(id: ::Integer, method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+ def initialize(id, method, params); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#41
+ sig { returns(::Integer) }
+ def id; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/base.rb#44
+ sig { returns(T::Hash[T.untyped, T.untyped]) }
+ def params; end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/errors.rb#40
+class Spoom::LSP::ResponseError < ::Spoom::LSP::Error
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#63
+ sig { params(code: ::Integer, message: ::String, data: T::Hash[T.untyped, T.untyped]).void }
+ def initialize(code, message, data); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#44
+ sig { returns(::Integer) }
+ def code; end
+
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#47
+ sig { returns(T::Hash[T.untyped, T.untyped]) }
+ def data; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/errors.rb#53
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::ResponseError) }
+ def from_json(json); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#143
+class Spoom::LSP::SignatureHelp < ::T::Struct
+ include ::Spoom::LSP::PrintableSymbol
+
+ const :label, T.nilable(::String)
+ const :doc, ::Object
+ const :params, T::Array[T.untyped]
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#165
+ sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+ def accept_printer(printer); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#173
+ sig { returns(::String) }
+ def to_s; end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#155
+ sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) }
+ def from_json(json); end
+
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/lsp/structures.rb#309
+class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#326
+ sig do
+ params(
+ out: T.any(::IO, ::StringIO),
+ colors: T::Boolean,
+ indent_level: ::Integer,
+ prefix: T.nilable(::String)
+ ).void
+ end
+ def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil), prefix: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#348
+ sig { params(uri: ::String).returns(::String) }
+ def clean_uri(uri); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#316
+ sig { returns(T.nilable(::String)) }
+ def prefix; end
+
+ # @return [String, nil]
+ #
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#316
+ def prefix=(_arg0); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#356
+ sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+ def print_list(objects); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#336
+ sig { params(object: T.nilable(::Spoom::LSP::PrintableSymbol)).void }
+ def print_object(object); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#343
+ sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+ def print_objects(objects); end
+
+ # source://spoom//lib/spoom/sorbet/lsp/structures.rb#313
+ sig { returns(T::Set[::Integer]) }
+ def seen; end
+end
+
+# source://spoom//lib/spoom/printer.rb#7
+class Spoom::Printer
+ include ::Spoom::Colorize
+
+ # source://spoom//lib/spoom/printer.rb#17
+ sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+ def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+ # Colorize `string` with color if `@colors`
+ #
+ # source://spoom//lib/spoom/printer.rb#78
+ sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+ def colorize(string, *color); end
+
+ # Decrease indent level
+ #
+ # source://spoom//lib/spoom/printer.rb#31
+ sig { void }
+ def dedent; end
+
+ # Increase indent level
+ #
+ # source://spoom//lib/spoom/printer.rb#25
+ sig { void }
+ def indent; end
+
+ # source://spoom//lib/spoom/printer.rb#14
+ sig { returns(T.any(::IO, ::StringIO)) }
+ def out; end
+
+ # @return [IO, StringIO]
+ #
+ # source://spoom//lib/spoom/printer.rb#14
+ def out=(_arg0); end
+
+ # Print `string` into `out`
+ #
+ # source://spoom//lib/spoom/printer.rb#37
+ sig { params(string: T.nilable(::String)).void }
+ def print(string); end
+
+ # Print `string` colored with `color` into `out`
+ #
+ # Does not use colors unless `@colors`.
+ #
+ # source://spoom//lib/spoom/printer.rb#47
+ sig { params(string: T.nilable(::String), color: ::Spoom::Color).void }
+ def print_colored(string, *color); end
+
+ # Print `string` with indent and newline
+ #
+ # source://spoom//lib/spoom/printer.rb#62
+ sig { params(string: T.nilable(::String)).void }
+ def printl(string); end
+
+ # Print a new line into `out`
+ #
+ # source://spoom//lib/spoom/printer.rb#56
+ sig { void }
+ def printn; end
+
+ # Print an indent space into `out`
+ #
+ # source://spoom//lib/spoom/printer.rb#72
+ sig { void }
+ def printt; end
+end
+
+# source://spoom//lib/spoom.rb#10
+Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/config.rb#5
+module Spoom::Sorbet; end
+
+# source://spoom//lib/spoom/sorbet.rb#39
+Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#36
+Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
+
+# Parse Sorbet config files
+#
+# Parses a Sorbet config file:
+#
+# ```ruby
+# config = Spoom::Sorbet::Config.parse_file("sorbet/config")
+# puts config.paths # "."
+# ```
+#
+# Parses a Sorbet config string:
+#
+# ```ruby
+# config = Spoom::Sorbet::Config.parse_string(<<~CONFIG)
+# a
+# --file=b
+# --ignore=c
+# CONFIG
+# puts config.paths # "a", "b"
+# puts config.ignore # "c"
+# ```
+#
+# source://spoom//lib/spoom/sorbet/config.rb#26
+class Spoom::Sorbet::Config
+ # source://spoom//lib/spoom/sorbet/config.rb#38
+ sig { void }
+ def initialize; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ def allowed_extensions; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ def allowed_extensions=(_arg0); end
+
+ # source://spoom//lib/spoom/sorbet/config.rb#46
+ sig { returns(::Spoom::Sorbet::Config) }
+ def copy; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ def ignore; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ def ignore=(_arg0); end
+
+ # source://spoom//lib/spoom/sorbet/config.rb#35
+ sig { returns(T::Boolean) }
+ def no_stdlib; end
+
+ # @return [Boolean]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#35
+ def no_stdlib=(_arg0); end
+
+ # Returns self as a string of options that can be passed to Sorbet
+ #
+ # Example:
+ # ~~~rb
+ # config = Sorbet::Config.new
+ # config.paths << "/foo"
+ # config.paths << "/bar"
+ # config.ignore << "/baz"
+ # config.allowed_extensions << ".rb"
+ #
+ # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb"
+ # ~~~
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#68
+ sig { returns(::String) }
+ def options_string; end
+
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ sig { returns(T::Array[::String]) }
+ def paths; end
+
+ # @return [Array]
+ #
+ # source://spoom//lib/spoom/sorbet/config.rb#32
+ def paths=(_arg0); end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/config.rb#81
+ sig { params(sorbet_config_path: ::String).returns(::Spoom::Sorbet::Config) }
+ def parse_file(sorbet_config_path); end
+
+ # source://spoom//lib/spoom/sorbet/config.rb#86
+ sig { params(sorbet_config: ::String).returns(::Spoom::Sorbet::Config) }
+ def parse_string(sorbet_config); end
+
+ private
+
+ # source://spoom//lib/spoom/sorbet/config.rb#150
+ sig { params(line: ::String).returns(::String) }
+ def parse_option(line); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/config.rb#29
+Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/sorbet.rb#14
+class Spoom::Sorbet::Error < ::StandardError
+ # source://spoom//lib/spoom/sorbet.rb#29
+ sig { params(message: ::String, result: ::Spoom::ExecResult).void }
+ def initialize(message, result); end
+
+ # source://spoom//lib/spoom/sorbet.rb#21
+ sig { returns(::Spoom::ExecResult) }
+ def result; end
+end
+
+# source://spoom//lib/spoom/sorbet.rb#17
+class Spoom::Sorbet::Error::Killed < ::Spoom::Sorbet::Error; end
+
+# source://spoom//lib/spoom/sorbet.rb#18
+class Spoom::Sorbet::Error::Segfault < ::Spoom::Sorbet::Error; end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#6
+module Spoom::Sorbet::Errors
+ class << self
+ # source://spoom//lib/spoom/sorbet/errors.rb#13
+ sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+ def sort_errors_by_code(errors); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#7
+Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/errors.rb#125
+class Spoom::Sorbet::Errors::Error
+ include ::Comparable
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#151
+ sig do
+ params(
+ file: T.nilable(::String),
+ line: T.nilable(::Integer),
+ message: T.nilable(::String),
+ code: T.nilable(::Integer),
+ more: T::Array[::String]
+ ).void
+ end
+ def initialize(file, line, message, code, more = T.unsafe(nil)); end
+
+ # By default errors are sorted by location
+ #
+ # source://spoom//lib/spoom/sorbet/errors.rb#162
+ sig { params(other: T.untyped).returns(::Integer) }
+ def <=>(other); end
+
+ # @return [Integer, nil]
+ #
+ # source://spoom//lib/spoom/sorbet/errors.rb#133
+ def code; end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#130
+ sig { returns(T.nilable(::String)) }
+ def file; end
+
+ # Other files associated with the error
+ #
+ # source://spoom//lib/spoom/sorbet/errors.rb#140
+ sig { returns(T::Set[::String]) }
+ def files_from_error_sections; end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#133
+ sig { returns(T.nilable(::Integer)) }
+ def line; end
+
+ # @return [String, nil]
+ #
+ # source://spoom//lib/spoom/sorbet/errors.rb#130
+ def message; end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#136
+ sig { returns(T::Array[::String]) }
+ def more; end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#169
+ sig { returns(::String) }
+ def to_s; end
+end
+
+# Parse errors from Sorbet output
+#
+# source://spoom//lib/spoom/sorbet/errors.rb#18
+class Spoom::Sorbet::Errors::Parser
+ # source://spoom//lib/spoom/sorbet/errors.rb#43
+ sig { params(error_url_base: ::String).void }
+ def initialize(error_url_base: T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#50
+ sig { params(output: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+ def parse(output); end
+
+ private
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#114
+ sig { params(line: ::String).void }
+ def append_error(line); end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#106
+ sig { void }
+ def close_error; end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#73
+ sig { params(error_url_base: ::String).returns(::Regexp) }
+ def error_line_match_regexp(error_url_base); end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#90
+ sig { params(line: ::String).returns(T.nilable(::Spoom::Sorbet::Errors::Error)) }
+ def match_error_line(line); end
+
+ # source://spoom//lib/spoom/sorbet/errors.rb#99
+ sig { params(error: ::Spoom::Sorbet::Errors::Error).void }
+ def open_error(error); end
+
+ class << self
+ # source://spoom//lib/spoom/sorbet/errors.rb#36
+ sig { params(output: ::String, error_url_base: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+ def parse_string(output, error_url_base: T.unsafe(nil)); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/errors.rb#21
+Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/sorbet.rb#37
+Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#38
+Spoom::Sorbet::GEM_VERSION = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#41
+Spoom::Sorbet::KILLED_CODE = T.let(T.unsafe(nil), Integer)
+
+# source://spoom//lib/spoom/sorbet/metrics.rb#8
+module Spoom::Sorbet::MetricsParser
+ class << self
+ # source://spoom//lib/spoom/sorbet/metrics.rb#15
+ sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+ def parse_file(path, prefix = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/metrics.rb#25
+ sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+ def parse_hash(obj, prefix = T.unsafe(nil)); end
+
+ # source://spoom//lib/spoom/sorbet/metrics.rb#20
+ sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+ def parse_string(string, prefix = T.unsafe(nil)); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/metrics.rb#9
+Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet.rb#42
+Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#9
+module Spoom::Sorbet::Sigils
+ class << self
+ # changes the sigil in the file at the passed path to the specified new strictness
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#72
+ sig { params(path: T.any(::Pathname, ::String), new_strictness: ::String).returns(T::Boolean) }
+ def change_sigil_in_file(path, new_strictness); end
+
+ # changes the sigil to have a new strictness in a list of files
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#83
+ sig { params(path_list: T::Array[::String], new_strictness: ::String).returns(T::Array[::String]) }
+ def change_sigil_in_files(path_list, new_strictness); end
+
+ # returns a string containing the strictness of a sigil in a file at the passed path
+ # * returns nil if no sigil
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#63
+ sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) }
+ def file_strictness(path); end
+
+ # returns the full sigil comment string for the passed strictness
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#38
+ sig { params(strictness: ::String).returns(::String) }
+ def sigil_string(strictness); end
+
+ # returns the strictness of a sigil in the passed file content string (nil if no sigil)
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#50
+ sig { params(content: ::String).returns(T.nilable(::String)) }
+ def strictness_in_content(content); end
+
+ # returns a string which is the passed content but with the sigil updated to a new strictness
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#56
+ sig { params(content: ::String, new_strictness: ::String).returns(::String) }
+ def update_sigil(content, new_strictness); end
+
+ # returns true if the passed string is a valid strictness (else false)
+ #
+ # source://spoom//lib/spoom/sorbet/sigils.rb#44
+ sig { params(strictness: ::String).returns(T::Boolean) }
+ def valid_strictness?(strictness); end
+ end
+end
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#31
+Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#13
+Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#12
+Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#17
+Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#15
+Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#16
+Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#14
+Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
+
+# source://spoom//lib/spoom/sorbet/sigils.rb#19
+Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
+
+# source://spoom//lib/spoom/timeline.rb#5
+class Spoom::Timeline
+ # source://spoom//lib/spoom/timeline.rb#9
+ sig { params(context: ::Spoom::Context, from: ::Time, to: ::Time).void }
+ def initialize(context, from, to); end
+
+ # Return one commit for each date in `dates`
+ #
+ # source://spoom//lib/spoom/timeline.rb#36
+ sig { params(dates: T::Array[::Time]).returns(T::Array[::Spoom::Git::Commit]) }
+ def commits_for_dates(dates); end
+
+ # Return all months between `from` and `to`
+ #
+ # source://spoom//lib/spoom/timeline.rb#23
+ sig { returns(T::Array[::Time]) }
+ def months; end
+
+ # Return one commit for each month between `from` and `to`
+ #
+ # source://spoom//lib/spoom/timeline.rb#17
+ sig { returns(T::Array[::Spoom::Git::Commit]) }
+ def ticks; end
+end
+
+# source://spoom//lib/spoom/version.rb#5
+Spoom::VERSION = T.let(T.unsafe(nil), String)
diff --git a/2023/sorbet/rbi/gems/syntax_tree@6.2.0.rbi b/2023/sorbet/rbi/gems/syntax_tree@6.2.0.rbi
new file mode 100644
index 0000000..0ecc1a4
--- /dev/null
+++ b/2023/sorbet/rbi/gems/syntax_tree@6.2.0.rbi
@@ -0,0 +1,23136 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `syntax_tree` gem.
+# Please instead update this file by running `bin/tapioca gem syntax_tree`.
+
+# Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
+# provides the ability to generate a syntax tree from source, as well as the
+# tools necessary to inspect and manipulate that syntax tree. It can be used to
+# build formatters, linters, language servers, and more.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3
+module SyntaxTree
+ class << self
+ # Parses the given source and returns the formatted source.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#60
+ def format(source, maxwidth = T.unsafe(nil), base_indentation = T.unsafe(nil), options: T.unsafe(nil)); end
+
+ # Parses the given file and returns the formatted source.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#76
+ def format_file(filepath, maxwidth = T.unsafe(nil), base_indentation = T.unsafe(nil), options: T.unsafe(nil)); end
+
+ # Accepts a node in the tree and returns the formatted source.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#86
+ def format_node(source, node, maxwidth = T.unsafe(nil), base_indentation = T.unsafe(nil), options: T.unsafe(nil)); end
+
+ # Indexes the given source code to return a list of all class, module, and
+ # method definitions. Used to quickly provide indexing capability for IDEs or
+ # documentation generation.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#103
+ def index(source); end
+
+ # Indexes the given file to return a list of all class, module, and method
+ # definitions. Used to quickly provide indexing capability for IDEs or
+ # documentation generation.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#110
+ def index_file(filepath); end
+
+ # A convenience method for creating a new mutation visitor.
+ #
+ # @yield [visitor]
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#115
+ def mutation; end
+
+ # Parses the given source and returns the syntax tree.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#122
+ def parse(source); end
+
+ # Parses the given file and returns the syntax tree.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#129
+ def parse_file(filepath); end
+
+ # Returns the source from the given filepath taking into account any potential
+ # magic encoding comments.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#135
+ def read(filepath); end
+
+ # This is a hook provided so that plugins can register themselves as the
+ # handler for a particular file type.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#150
+ def register_handler(extension, handler); end
+
+ # Searches through the given source using the given pattern and yields each
+ # node in the tree that matches the pattern to the given block.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#156
+ def search(source, query, &block); end
+
+ # Searches through the given file using the given pattern and yields each
+ # node in the tree that matches the pattern to the given block.
+ #
+ # source://syntax_tree//lib/syntax_tree.rb#165
+ def search_file(filepath, query, &block); end
+ end
+end
+
+# ARef represents when you're pulling a value out of a collection at a
+# specific index. Put another way, it's any time you're calling the method
+# #[].
+#
+# collection[index]
+#
+# The nodes usually contains two children, the collection and the index. In
+# some cases, you don't necessarily have the second child node, because you
+# can call procs with a pretty esoteric syntax. In the following example, you
+# wouldn't have a second child node:
+#
+# collection[]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#567
+class SyntaxTree::ARef < ::SyntaxTree::Node
+ # @return [ARef] a new instance of ARef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#577
+ def initialize(collection:, index:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#632
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#584
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#588
+ def child_nodes; end
+
+ # [Node] the value being indexed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#569
+ def collection; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#575
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#592
+ def copy(collection: T.unsafe(nil), index: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#588
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#606
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#615
+ def format(q); end
+
+ # [nil | Args] the value being passed within the brackets
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#572
+ def index; end
+end
+
+# ARefField represents assigning values into collections at specific indices.
+# Put another way, it's any time you're calling the method #[]=. The
+# ARefField node itself is just the left side of the assignment, and they're
+# always wrapped in assign nodes.
+#
+# collection[index] = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#645
+class SyntaxTree::ARefField < ::SyntaxTree::Node
+ # @return [ARefField] a new instance of ARefField
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#655
+ def initialize(collection:, index:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#710
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#662
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#666
+ def child_nodes; end
+
+ # [Node] the value being indexed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#647
+ def collection; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#653
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#670
+ def copy(collection: T.unsafe(nil), index: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#666
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#684
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#693
+ def format(q); end
+
+ # [nil | Args] the value being passed within the brackets
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#650
+ def index; end
+end
+
+# Alias represents the use of the +alias+ keyword with regular arguments (not
+# global variables). The +alias+ keyword is used to make a method respond to
+# another name as well as the current one.
+#
+# alias aliased_name name
+#
+# For the example above, in the current context you can now call aliased_name
+# and it will execute the name method. When you're aliasing two methods, you
+# can either provide bare words (like the example above) or you can provide
+# symbols (note that this includes dynamic symbols like
+# :"left-#{middle}-right").
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#458
+class SyntaxTree::AliasNode < ::SyntaxTree::Node
+ # @return [AliasNode] a new instance of AliasNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#496
+ def initialize(left:, right:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#545
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#503
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#507
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#494
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#511
+ def copy(left: T.unsafe(nil), right: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#507
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#525
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#529
+ def format(q); end
+
+ # [DynaSymbol | GVar | SymbolLiteral] the new name of the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#488
+ def left; end
+
+ # [Backref | DynaSymbol | GVar | SymbolLiteral] the old name of the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#491
+ def right; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#549
+ def var_alias?; end
+end
+
+# Formats an argument to the alias keyword. For symbol literals it uses the
+# value of the symbol directly to look like bare words.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#461
+class SyntaxTree::AliasNode::AliasArgumentFormatter
+ # @return [AliasArgumentFormatter] a new instance of AliasArgumentFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#466
+ def initialize(argument); end
+
+ # [Backref | DynaSymbol | GVar | SymbolLiteral] the argument being passed
+ # to alias
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#464
+ def argument; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#470
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#478
+ def format(q); end
+end
+
+# ArgBlock represents using a block operator on an expression.
+#
+# method(&expression)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#887
+class SyntaxTree::ArgBlock < ::SyntaxTree::Node
+ # @return [ArgBlock] a new instance of ArgBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#894
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#930
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#900
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#904
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#892
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#908
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#904
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#921
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#925
+ def format(q); end
+
+ # [nil | Node] the expression being turned into a block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#889
+ def value; end
+end
+
+# ArgParen represents wrapping arguments to a method inside a set of
+# parentheses.
+#
+# method(argument)
+#
+# In the example above, there would be an ArgParen node around the Args node
+# that represents the set of arguments being sent to the method method. The
+# argument child node can be +nil+ if no arguments were passed, as in:
+#
+# method()
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#727
+class SyntaxTree::ArgParen < ::SyntaxTree::Node
+ # @return [ArgParen] a new instance of ArgParen
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#735
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#784
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#741
+ def accept(visitor); end
+
+ # [nil | Args | ArgsForward] the arguments inside the
+ # parentheses
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#730
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#788
+ def arity; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#745
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#733
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#749
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#745
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#762
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#766
+ def format(q); end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#794
+ def trailing_comma?; end
+end
+
+# Star represents using a splat operator on an expression.
+#
+# method(*arguments)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#939
+class SyntaxTree::ArgStar < ::SyntaxTree::Node
+ # @return [ArgStar] a new instance of ArgStar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#946
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#982
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#952
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#956
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#944
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#960
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#956
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#973
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#977
+ def format(q); end
+
+ # [nil | Node] the expression being splatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#941
+ def value; end
+end
+
+# Args represents a list of arguments being passed to a method call or array
+# literal.
+#
+# method(first, second, third)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#821
+class SyntaxTree::Args < ::SyntaxTree::Node
+ # @return [Args] a new instance of Args
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#828
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#863
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#834
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#867
+ def arity; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#838
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#826
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#842
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#838
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#855
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#859
+ def format(q); end
+
+ # [Array[ Node ]] the arguments that this node wraps
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#823
+ def parts; end
+end
+
+# ArgsForward represents forwarding all kinds of arguments onto another method
+# call.
+#
+# def request(method, path, **headers, &block); end
+#
+# def get(...)
+# request(:GET, ...)
+# end
+#
+# def post(...)
+# request(:POST, ...)
+# end
+#
+# In the example above, both the get and post methods are forwarding all of
+# their arguments (positional, keyword, and block) on to the request method.
+# The ArgsForward node appears in both the caller (the request method calls)
+# and the callee (the get and post definitions).
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1004
+class SyntaxTree::ArgsForward < ::SyntaxTree::Node
+ # @return [ArgsForward] a new instance of ArgsForward
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1008
+ def initialize(location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1038
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1013
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1042
+ def arity; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1017
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1006
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1021
+ def copy(location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1017
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1030
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1034
+ def format(q); end
+end
+
+# ArrayLiteral represents an array literal, which can optionally contain
+# elements.
+#
+# []
+# [one, two, three]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1053
+class SyntaxTree::ArrayLiteral < ::SyntaxTree::Node
+ # @return [ArrayLiteral] a new instance of ArrayLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1153
+ def initialize(lbracket:, contents:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1229
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1160
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1164
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1151
+ def comments; end
+
+ # [nil | Args] the contents of the array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1148
+ def contents; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1168
+ def copy(lbracket: T.unsafe(nil), contents: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1164
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1182
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1191
+ def format(q); end
+
+ # [nil | LBracket | QSymbolsBeg | QWordsBeg | SymbolsBeg | WordsBeg] the
+ # bracket that opens this array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1145
+ def lbracket; end
+
+ private
+
+ # If we have an empty array that contains only comments, then we're going
+ # to do some special printing to ensure they get indented correctly.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1259
+ def empty_with_comments?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1251
+ def qsymbols?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1236
+ def qwords?; end
+end
+
+# source://syntax_tree//lib/syntax_tree/node.rb#1063
+SyntaxTree::ArrayLiteral::BREAKABLE_SPACE_SEPARATOR = T.let(T.unsafe(nil), SyntaxTree::ArrayLiteral::BreakableSpaceSeparator)
+
+# It's very common to use seplist with ->(q) { q.breakable_space }. We wrap
+# that pattern into an object to cut down on having to create a bunch of
+# lambdas all over the place.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1057
+class SyntaxTree::ArrayLiteral::BreakableSpaceSeparator
+ # source://syntax_tree//lib/syntax_tree/node.rb#1058
+ def call(q); end
+end
+
+# This is a special formatter used if the array literal contains no values
+# but _does_ contain comments. In this case we do some special formatting to
+# make sure the comments gets indented properly.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1120
+class SyntaxTree::ArrayLiteral::EmptyWithCommentsFormatter
+ # @return [EmptyWithCommentsFormatter] a new instance of EmptyWithCommentsFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1124
+ def initialize(lbracket); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1128
+ def format(q); end
+
+ # [LBracket] the opening bracket
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1122
+ def lbracket; end
+end
+
+# Formats an array of multiple simple symbol literals into the %i syntax.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1094
+class SyntaxTree::ArrayLiteral::QSymbolsFormatter
+ # @return [QSymbolsFormatter] a new instance of QSymbolsFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1098
+ def initialize(contents); end
+
+ # [Args] the contents of the array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1096
+ def contents; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1102
+ def format(q); end
+end
+
+# Formats an array of multiple simple string literals into the %w syntax.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1066
+class SyntaxTree::ArrayLiteral::QWordsFormatter
+ # @return [QWordsFormatter] a new instance of QWordsFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1070
+ def initialize(contents); end
+
+ # [Args] the contents of the array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1068
+ def contents; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1074
+ def format(q); end
+end
+
+# When we're implementing the === operator for a node, we oftentimes need to
+# compare two arrays. We want to skip over the === definition of array and use
+# our own here, so we do that using this module.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#157
+module SyntaxTree::ArrayMatch
+ class << self
+ # source://syntax_tree//lib/syntax_tree/node.rb#158
+ def call(left, right); end
+ end
+end
+
+# AryPtn represents matching against an array pattern using the Ruby 2.7+
+# pattern matching syntax. It’s one of the more complicated nodes, because
+# the four parameters that it accepts can almost all be nil.
+#
+# case [1, 2, 3]
+# in [Integer, Integer]
+# "matched"
+# in Container[Integer, Integer]
+# "matched"
+# in [Integer, *, Integer]
+# "matched"
+# end
+#
+# An AryPtn node is created with four parameters: an optional constant
+# wrapper, an array of positional matches, an optional splat with identifier,
+# and an optional array of positional matches that occur after the splat.
+# All of the in clauses above would create an AryPtn node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1282
+class SyntaxTree::AryPtn < ::SyntaxTree::Node
+ # @return [AryPtn] a new instance of AryPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1320
+ def initialize(constant:, requireds:, rest:, posts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1388
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1329
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1333
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1318
+ def comments; end
+
+ # [nil | VarRef | ConstPathRef] the optional constant wrapper
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1303
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1337
+ def copy(constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1333
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1359
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1370
+ def format(q); end
+
+ # [Array[ Node ]] the list of positional arguments occurring after the
+ # optional star if there is one
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1315
+ def posts; end
+
+ # [Array[ Node ]] the regular positional arguments that this array
+ # pattern is matching against
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1307
+ def requireds; end
+
+ # [nil | VarField] the optional starred identifier that grabs up a list of
+ # positional arguments
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1311
+ def rest; end
+end
+
+# Formats the optional splat of an array pattern.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1284
+class SyntaxTree::AryPtn::RestFormatter
+ # @return [RestFormatter] a new instance of RestFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1288
+ def initialize(value); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1292
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1296
+ def format(q); end
+
+ # [VarField] the identifier that represents the remaining positionals
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1286
+ def value; end
+end
+
+# Assign represents assigning something to a variable or constant. Generally,
+# the left side of the assignment is going to be any node that ends with the
+# name "Field".
+#
+# variable = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1418
+class SyntaxTree::Assign < ::SyntaxTree::Node
+ # @return [Assign] a new instance of Assign
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1429
+ def initialize(target:, value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1479
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1436
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1440
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1427
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1444
+ def copy(target: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1440
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1458
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1462
+ def format(q); end
+
+ # [ARefField | ConstPathField | Field | TopConstField | VarField] the target
+ # to assign the result of the expression to
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1421
+ def target; end
+
+ # [Node] the expression to be assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1424
+ def value; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1485
+ def skip_indent?; end
+end
+
+# Determins if the following value should be indented or not.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1396
+module SyntaxTree::AssignFormatting
+ class << self
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1397
+ def skip_indent?(value); end
+ end
+end
+
+# Assoc represents a key-value pair within a hash. It is a child node of
+# either an AssocListFromArgs or a BareAssocHash.
+#
+# { key1: value1, key2: value2 }
+#
+# In the above example, the would be two Assoc nodes.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1497
+class SyntaxTree::Assoc < ::SyntaxTree::Node
+ # @return [Assoc] a new instance of Assoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1507
+ def initialize(key:, value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1548
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1514
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1518
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1505
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1522
+ def copy(key: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1518
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1536
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1540
+ def format(q); end
+
+ # [Node] the key of this pair
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1499
+ def key; end
+
+ # [nil | Node] the value of this pair
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1502
+ def value; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1554
+ def format_contents(q); end
+end
+
+# AssocSplat represents double-splatting a value into a hash (either a hash
+# literal or a bare hash in a method call).
+#
+# { **pairs }
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1575
+class SyntaxTree::AssocSplat < ::SyntaxTree::Node
+ # @return [AssocSplat] a new instance of AssocSplat
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1582
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1618
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1588
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1592
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1580
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1596
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1592
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1609
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1613
+ def format(q); end
+
+ # [nil | Node] the expression that is being splatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1577
+ def value; end
+end
+
+# BEGINBlock represents the use of the +BEGIN+ keyword, which hooks into the
+# lifecycle of the interpreter. Whatever is inside the block will get executed
+# when the program starts.
+#
+# BEGIN {
+# }
+#
+# Interestingly, the BEGIN keyword doesn't allow the do and end keywords for
+# the block. Only braces are permitted.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#175
+class SyntaxTree::BEGINBlock < ::SyntaxTree::Node
+ # @return [BEGINBlock] a new instance of BEGINBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#185
+ def initialize(lbrace:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#236
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#192
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#196
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#183
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#200
+ def copy(lbrace: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#196
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#214
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#223
+ def format(q); end
+
+ # [LBrace] the left brace that is seen after the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#177
+ def lbrace; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#180
+ def statements; end
+end
+
+# Backref represents a global variable referencing a matched value. It comes
+# in the form of a $ followed by a positive integer.
+#
+# $1
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1628
+class SyntaxTree::Backref < ::SyntaxTree::Node
+ # @return [Backref] a new instance of Backref
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1635
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1670
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1641
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1645
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1633
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1649
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1645
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1662
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1666
+ def format(q); end
+
+ # [String] the name of the global backreference variable
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1630
+ def value; end
+end
+
+# Backtick represents the use of the ` operator. It's usually found being used
+# for an XStringLiteral, but could also be found as the name of a method being
+# defined.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1678
+class SyntaxTree::Backtick < ::SyntaxTree::Node
+ # @return [Backtick] a new instance of Backtick
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1685
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1720
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1691
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1695
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1683
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1699
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1695
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1712
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1716
+ def format(q); end
+
+ # [String] the backtick in the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1680
+ def value; end
+end
+
+# BareAssocHash represents a hash of contents being passed as a method
+# argument (and therefore has omitted braces). It's very similar to an
+# AssocListFromArgs node.
+#
+# method(key1: value1, key2: value2)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1834
+class SyntaxTree::BareAssocHash < ::SyntaxTree::Node
+ # @return [BareAssocHash] a new instance of BareAssocHash
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1841
+ def initialize(assocs:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1876
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1847
+ def accept(visitor); end
+
+ # [Array[ Assoc | AssocSplat ]]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1836
+ def assocs; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1851
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1839
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1855
+ def copy(assocs: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1851
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1868
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1872
+ def format(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1880
+ def format_key(q, key); end
+end
+
+# BasicVisitor is the parent class of the Visitor class that provides the
+# ability to walk down the tree. It does not define any handlers, so you
+# should extend this class if you want your visitor to raise an error if you
+# attempt to visit a node that you don't handle.
+#
+# source://syntax_tree//lib/syntax_tree/basic_visitor.rb#8
+class SyntaxTree::BasicVisitor
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#105
+ def visit(node); end
+
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#109
+ def visit_all(nodes); end
+
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_child_nodes(node); end
+
+ class << self
+ # This is the list of all of the valid visit methods.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#72
+ def valid_visit_methods; end
+
+ # This method is here to help folks write visitors.
+ #
+ # It's not always easy to ensure you're writing the correct method name in
+ # the visitor since it's perfectly valid to define methods that don't
+ # override these parent methods.
+ #
+ # If you use this method, you can ensure you're writing the correct method
+ # name. It will raise an error if the visit method you're defining isn't
+ # actually a method on the parent visitor.
+ #
+ # @raise [VisitMethodError]
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#86
+ def visit_method(method_name); end
+
+ # This method is here to help folks write visitors.
+ #
+ # Within the given block, every method that is defined will be checked to
+ # ensure it's a valid visit method using the BasicVisitor::visit_method
+ # method defined above.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#97
+ def visit_methods; end
+ end
+end
+
+# This class is used by DidYouMean to offer corrections to invalid visit
+# method names.
+#
+# source://syntax_tree//lib/syntax_tree/basic_visitor.rb#22
+class SyntaxTree::BasicVisitor::VisitMethodChecker
+ # @return [VisitMethodChecker] a new instance of VisitMethodChecker
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#25
+ def initialize(error); end
+
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#29
+ def corrections; end
+
+ # Returns the value of attribute visit_method.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#23
+ def visit_method; end
+end
+
+# This is raised when you use the Visitor.visit_method method and it fails.
+# It is correctable to through DidYouMean.
+#
+# source://syntax_tree//lib/syntax_tree/basic_visitor.rb#11
+class SyntaxTree::BasicVisitor::VisitMethodError < ::StandardError
+ include ::DidYouMean::Correctable
+
+ # @return [VisitMethodError] a new instance of VisitMethodError
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#14
+ def initialize(visit_method); end
+
+ # Returns the value of attribute visit_method.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#12
+ def visit_method; end
+end
+
+# This module is responsible for checking all of the methods defined within
+# a given block to ensure that they are valid visit methods.
+#
+# source://syntax_tree//lib/syntax_tree/basic_visitor.rb#45
+class SyntaxTree::BasicVisitor::VisitMethodsChecker < ::Module
+ # @return [VisitMethodsChecker] a new instance of VisitMethodsChecker
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#53
+ def initialize; end
+
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#65
+ def disable!; end
+
+ # This is the status of the checker. It's used to determine whether or not
+ # we should be checking the methods that are defined. It is kept as an
+ # instance variable so that it can be disabled later.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#51
+ def status; end
+end
+
+# source://syntax_tree//lib/syntax_tree/basic_visitor.rb#46
+class SyntaxTree::BasicVisitor::VisitMethodsChecker::Status < ::Struct
+ # Returns the value of attribute checking
+ #
+ # @return [Object] the current value of checking
+ def checking; end
+
+ # Sets the attribute checking
+ #
+ # @param value [Object] the value to set the attribute checking to.
+ # @return [Object] the newly set value
+ def checking=(_); end
+
+ class << self
+ def [](*_arg0); end
+ def inspect; end
+ def keyword_init?; end
+ def members; end
+ def new(*_arg0); end
+ end
+end
+
+# Begin represents a begin..end chain.
+#
+# begin
+# value
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1899
+class SyntaxTree::Begin < ::SyntaxTree::Node
+ # @return [Begin] a new instance of Begin
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1906
+ def initialize(bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1951
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1912
+ def accept(visitor); end
+
+ # [BodyStmt] the bodystmt that contains the contents of this begin block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1901
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1916
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1904
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1920
+ def copy(bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1916
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1933
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1937
+ def format(q); end
+end
+
+# Binary represents any expression that involves two sub-expressions with an
+# operator in between. This can be something that looks like a mathematical
+# operation:
+#
+# 1 + 1
+#
+# but can also be something like pushing a value onto an array:
+#
+# array << value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2029
+class SyntaxTree::Binary < ::SyntaxTree::Node
+ # @return [Binary] a new instance of Binary
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2056
+ def initialize(left:, operator:, right:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2128
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2064
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2068
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2054
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2072
+ def copy(left: T.unsafe(nil), operator: T.unsafe(nil), right: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2068
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2087
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2097
+ def format(q); end
+
+ # [Node] the left-hand side of the expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2045
+ def left; end
+
+ # [Symbol] the operator used between the two expressions
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2048
+ def operator; end
+
+ # [Node] the right-hand side of the expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2051
+ def right; end
+end
+
+# BlockArg represents declaring a block parameter on a method definition.
+#
+# def method(&block); end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2227
+class SyntaxTree::BlockArg < ::SyntaxTree::Node
+ # @return [BlockArg] a new instance of BlockArg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2234
+ def initialize(name:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2270
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2240
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2244
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2232
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2248
+ def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2244
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2261
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2265
+ def format(q); end
+
+ # [nil | Ident] the name of the block argument
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2229
+ def name; end
+end
+
+# Block represents passing a block to a method call using the +do+ and +end+
+# keywords or the +{+ and +}+ operators.
+#
+# method do |value|
+# end
+#
+# method { |value| }
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4312
+class SyntaxTree::BlockNode < ::SyntaxTree::Node
+ # @return [BlockNode] a new instance of BlockNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4347
+ def initialize(opening:, block_var:, bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4420
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4355
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4429
+ def arity; end
+
+ # [nil | BlockVar] the optional variable declaration within this block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4339
+ def block_var; end
+
+ # [BodyStmt | Statements] the expressions to be executed within this block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4342
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4359
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4345
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4363
+ def copy(opening: T.unsafe(nil), block_var: T.unsafe(nil), bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4359
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4378
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4388
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4425
+ def keywords?; end
+
+ # [LBrace | Kw] the left brace or the do keyword that opens this block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4336
+ def opening; end
+
+ private
+
+ # If we're the predicate of a loop or conditional, then we're going to have
+ # to go with the {..} bounds.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4471
+ def forced_brace_bounds?(q); end
+
+ # If we're a sibling of a control-flow keyword, then we're going to have to
+ # use the do..end bounds.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4460
+ def forced_do_end_bounds?(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4487
+ def format_break(q, break_opening, break_closing); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4507
+ def format_flat(q, flat_opening, flat_closing); end
+
+ # If this is nested anywhere inside certain nodes, then we can't change
+ # which operators/keywords we're using for the bounds of the block.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4442
+ def unchangeable_bounds?(q); end
+end
+
+# Formats the opening brace or keyword of a block.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4314
+class SyntaxTree::BlockNode::BlockOpenFormatter
+ # @return [BlockOpenFormatter] a new instance of BlockOpenFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4321
+ def initialize(text, node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4326
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4330
+ def format(q); end
+
+ # [LBrace | Keyword] the node that is being represented
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4319
+ def node; end
+
+ # [String] the actual output that should be printed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4316
+ def text; end
+end
+
+# BlockVar represents the parameters being declared for a block. Effectively
+# this node is everything contained within the pipes. This includes all of the
+# various parameter types, as well as block-local variable declarations.
+#
+# method do |positional, optional = value, keyword:, █ local|
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2141
+class SyntaxTree::BlockVar < ::SyntaxTree::Node
+ # @return [BlockVar] a new instance of BlockVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2151
+ def initialize(params:, locals:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2209
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2158
+ def accept(visitor); end
+
+ # When a single required parameter is declared for a block, it gets
+ # automatically expanded if the values being yielded into it are an array.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2216
+ def arg0?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2162
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2149
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2166
+ def copy(params: T.unsafe(nil), locals: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2162
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2180
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2196
+ def format(q); end
+
+ # [Array[ Ident ]] the list of block-local variable declarations
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2146
+ def locals; end
+
+ # [Params] the parameters being declared with the block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2143
+ def params; end
+end
+
+# We'll keep a single instance of this separator around for all block vars
+# to cut down on allocations.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2194
+SyntaxTree::BlockVar::SEPARATOR = T.let(T.unsafe(nil), SyntaxTree::BlockVar::Separator)
+
+# Within the pipes of the block declaration, we don't want any spaces. So
+# we'll separate the parameters with a comma and space but no breakables.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2186
+class SyntaxTree::BlockVar::Separator
+ # source://syntax_tree//lib/syntax_tree/node.rb#2187
+ def call(q); end
+end
+
+# bodystmt can't actually determine its bounds appropriately because it
+# doesn't necessarily know where it started. So the parent node needs to
+# report back down into this one where it goes.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2278
+class SyntaxTree::BodyStmt < ::SyntaxTree::Node
+ # @return [BodyStmt] a new instance of BodyStmt
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2297
+ def initialize(statements:, rescue_clause:, else_keyword:, else_clause:, ensure_clause:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2428
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2352
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2314
+ def bind(parser, start_char, start_column, end_char, end_column); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2356
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2295
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2360
+ def copy(statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_keyword: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2356
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2384
+ def deconstruct_keys(_keys); end
+
+ # [nil | Statements] the optional set of statements inside the else clause
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2289
+ def else_clause; end
+
+ # [nil | Kw] the optional else keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2286
+ def else_keyword; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2348
+ def empty?; end
+
+ # [nil | Ensure] the optional ensure clause
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2292
+ def ensure_clause; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2396
+ def format(q); end
+
+ # [nil | Rescue] the optional rescue chain attached to the begin clause
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2283
+ def rescue_clause; end
+
+ # [Statements] the list of statements inside the begin clause
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2280
+ def statements; end
+end
+
+# Break represents using the +break+ keyword.
+#
+# break
+#
+# It can also optionally accept arguments, as in:
+#
+# break 1
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2634
+class SyntaxTree::Break < ::SyntaxTree::Node
+ # @return [Break] a new instance of Break
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2641
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2676
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2647
+ def accept(visitor); end
+
+ # [Args] the arguments being sent to the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2636
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2651
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2639
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2655
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2651
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2668
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2672
+ def format(q); end
+end
+
+# CHAR irepresents a single codepoint in the script encoding.
+#
+# ?a
+#
+# In the example above, the CHAR node represents the string literal "a". You
+# can use control characters with this as well, as in ?\C-a.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#248
+class SyntaxTree::CHAR < ::SyntaxTree::Node
+ # @return [CHAR] a new instance of CHAR
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#255
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#296
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#261
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#265
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#253
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#269
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#265
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#282
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#286
+ def format(q); end
+
+ # [String] the value of the character literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#250
+ def value; end
+end
+
+# CVar represents the use of a class variable.
+#
+# @@variable
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4046
+class SyntaxTree::CVar < ::SyntaxTree::Node
+ # @return [CVar] a new instance of CVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4053
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4088
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4059
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4063
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4051
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4067
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4063
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4080
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4084
+ def format(q); end
+
+ # [String] the name of the class variable
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4048
+ def value; end
+end
+
+# This is probably the most complicated formatter in this file. It's
+# responsible for formatting chains of method calls, with or without arguments
+# or blocks. In general, we want to go from something like
+#
+# foo.bar.baz
+#
+# to
+#
+# foo
+# .bar
+# .baz
+#
+# Of course there are a lot of caveats to that, including trailing operators
+# when necessary, where comments are places, how blocks are aligned, etc.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2721
+class SyntaxTree::CallChainFormatter
+ # @return [CallChainFormatter] a new instance of CallChainFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2725
+ def initialize(node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2729
+ def format(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2795
+ def format_chain(q, children); end
+
+ # [CallNode | MethodAddBlock] the top of the call chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2723
+ def node; end
+
+ private
+
+ # For certain nodes, we want to attach directly to the end and don't
+ # want to indent the first call. So we'll pop off the first children and
+ # format it separately here.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2898
+ def attach_directly?(node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2908
+ def format_child(q, child, skip_comments: T.unsafe(nil), skip_operator: T.unsafe(nil), skip_attached: T.unsafe(nil)); end
+
+ class << self
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2879
+ def chained?(node); end
+ end
+end
+
+# CallNode represents a method call.
+#
+# receiver.message
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2946
+class SyntaxTree::CallNode < ::SyntaxTree::Node
+ # @return [CallNode] a new instance of CallNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2962
+ def initialize(receiver:, operator:, message:, arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3057
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2971
+ def accept(visitor); end
+
+ # [nil | ArgParen | Args] the arguments to the method call
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2957
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3103
+ def arity; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2975
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2960
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2984
+ def copy(receiver: T.unsafe(nil), operator: T.unsafe(nil), message: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2975
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3006
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3017
+ def format(q); end
+
+ # Print out the arguments to this call. If there are no arguments, then do
+ # nothing.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3065
+ def format_arguments(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3075
+ def format_contents(q); end
+
+ # [:call | Backtick | Const | Ident | Op] the message being sent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2954
+ def message; end
+
+ # [nil | :"::" | Op | Period] the operator being used to send the message
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2951
+ def operator; end
+
+ # [nil | Node] the receiver of the method call
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2948
+ def receiver; end
+end
+
+# Wraps a call operator (which can be a string literal :: or an Op node or a
+# Period node) and formats it when called.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2683
+class SyntaxTree::CallOperatorFormatter
+ # @return [CallOperatorFormatter] a new instance of CallOperatorFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2687
+ def initialize(operator); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2691
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2695
+ def format(q); end
+
+ # [:"::" | Op | Period] the operator being formatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2685
+ def operator; end
+end
+
+# Case represents the beginning of a case chain.
+#
+# case value
+# when 1
+# "one"
+# when 2
+# "two"
+# else
+# "number"
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3119
+class SyntaxTree::Case < ::SyntaxTree::Node
+ # @return [Case] a new instance of Case
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3132
+ def initialize(keyword:, value:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3190
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3140
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3144
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3130
+ def comments; end
+
+ # [In | When] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3127
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3148
+ def copy(keyword: T.unsafe(nil), value: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3144
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3163
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3173
+ def format(q); end
+
+ # [Kw] the keyword that opens this expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3121
+ def keyword; end
+
+ # [nil | Node] optional value being switched on
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3124
+ def value; end
+end
+
+# Class represents defining a class using the +class+ keyword.
+#
+# class Container
+# end
+#
+# Classes can have path names as their class name in case it's being nested
+# under a namespace, as in:
+#
+# class Namespace::Container
+# end
+#
+# Classes can also be defined as a top-level path, in the case that it's
+# already in a namespace but you want to define it at the top-level instead,
+# as in:
+#
+# module OtherNamespace
+# class ::Namespace::Container
+# end
+# end
+#
+# All of these declarations can also have an optional superclass reference, as
+# in:
+#
+# class Child < Parent
+# end
+#
+# That superclass can actually be any Ruby expression, it doesn't necessarily
+# need to be a constant, as in:
+#
+# class Child < method
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3315
+class SyntaxTree::ClassDeclaration < ::SyntaxTree::Node
+ # @return [ClassDeclaration] a new instance of ClassDeclaration
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3329
+ def initialize(constant:, superclass:, bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3392
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3337
+ def accept(visitor); end
+
+ # [BodyStmt] the expressions to execute within the context of the class
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3324
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3341
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3327
+ def comments; end
+
+ # [ConstPathRef | ConstRef | TopConstRef] the name of the class being
+ # defined
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3318
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3345
+ def copy(constant: T.unsafe(nil), superclass: T.unsafe(nil), bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3341
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3360
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3370
+ def format(q); end
+
+ # [nil | Node] the optional superclass declaration
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3321
+ def superclass; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3399
+ def format_declaration(q); end
+end
+
+# Comma represents the use of the , operator.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3413
+class SyntaxTree::Comma < ::SyntaxTree::Node
+ # @return [Comma] a new instance of Comma
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3417
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3440
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3422
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3426
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3430
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3426
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3436
+ def deconstruct_keys(_keys); end
+
+ # [String] the comma in the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3415
+ def value; end
+end
+
+# Command represents a method call with arguments and no parentheses. Note
+# that Command nodes only happen when there is no explicit receiver for this
+# method.
+#
+# method argument
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3451
+class SyntaxTree::Command < ::SyntaxTree::Node
+ # @return [Command] a new instance of Command
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3464
+ def initialize(message:, arguments:, block:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3514
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3472
+ def accept(visitor); end
+
+ # [Args] the arguments being sent with the message
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3456
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3519
+ def arity; end
+
+ # [nil | BlockNode] the optional block being passed to the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3459
+ def block; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3476
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3462
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3480
+ def copy(message: T.unsafe(nil), arguments: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3476
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3495
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3505
+ def format(q); end
+
+ # [Const | Ident] the message being sent to the implicit receiver
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3453
+ def message; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3525
+ def align(q, node, &block); end
+end
+
+# CommandCall represents a method call on an object with arguments and no
+# parentheses.
+#
+# object.method argument
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3563
+class SyntaxTree::CommandCall < ::SyntaxTree::Node
+ # @return [CommandCall] a new instance of CommandCall
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3582
+ def initialize(receiver:, operator:, message:, arguments:, block:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3686
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3599
+ def accept(visitor); end
+
+ # [nil | Args | ArgParen] the arguments going along with the message
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3574
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3692
+ def arity; end
+
+ # [nil | BlockNode] the block associated with this method call
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3577
+ def block; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3603
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3580
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3607
+ def copy(receiver: T.unsafe(nil), operator: T.unsafe(nil), message: T.unsafe(nil), arguments: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3603
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3631
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3643
+ def format(q); end
+
+ # [:call | Const | Ident | Op] the message being send
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3571
+ def message; end
+
+ # [nil | :"::" | Op | Period] the operator used to send the message
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3568
+ def operator; end
+
+ # [nil | Node] the receiver of the message
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3565
+ def receiver; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3698
+ def argument_alignment(q, doc); end
+end
+
+# Comment represents a comment in the source.
+#
+# # comment
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3725
+class SyntaxTree::Comment < ::SyntaxTree::Node
+ # @return [Comment] a new instance of Comment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3734
+ def initialize(value:, inline:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3793
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3767
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3771
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3763
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3775
+ def copy(value: T.unsafe(nil), inline: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3771
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3785
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3789
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3759
+ def ignore?; end
+
+ # [boolean] whether or not there is code on the same line as this comment.
+ # If there is, then inline will be true.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3731
+ def inline; end
+
+ # [boolean] whether or not there is code on the same line as this comment.
+ # If there is, then inline will be true.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3731
+ def inline?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3743
+ def leading!; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3747
+ def leading?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3751
+ def trailing!; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3755
+ def trailing?; end
+
+ # [String] the contents of the comment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3727
+ def value; end
+end
+
+# Formats an If or Unless node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6317
+class SyntaxTree::ConditionalFormatter
+ # @return [ConditionalFormatter] a new instance of ConditionalFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6324
+ def initialize(keyword, node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6329
+ def format(q); end
+
+ # [String] the keyword associated with this conditional
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6319
+ def keyword; end
+
+ # [If | Unless] the node that is being formatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6322
+ def node; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6453
+ def contains_conditional?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6388
+ def format_break(q, force:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6380
+ def format_flat(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6408
+ def format_ternary(q); end
+end
+
+# Const represents a literal value that _looks_ like a constant. This could
+# actually be a reference to a constant:
+#
+# Constant
+#
+# It could also be something that looks like a constant in another context, as
+# in a method call to a capitalized method:
+#
+# object.Constant
+#
+# or a symbol that starts with a capital letter:
+#
+# :Constant
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3812
+class SyntaxTree::Const < ::SyntaxTree::Node
+ # @return [Const] a new instance of Const
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3819
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3854
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3825
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3829
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3817
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3833
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3829
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3846
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3850
+ def format(q); end
+
+ # [String] the name of the constant
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3814
+ def value; end
+end
+
+# ConstPathField represents the child node of some kind of assignment. It
+# represents when you're assigning to a constant that is being referenced as
+# a child of another variable.
+#
+# object::Const = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3865
+class SyntaxTree::ConstPathField < ::SyntaxTree::Node
+ # @return [ConstPathField] a new instance of ConstPathField
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3875
+ def initialize(parent:, constant:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3919
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3882
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3886
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3873
+ def comments; end
+
+ # [Const] the constant itself
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3870
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3890
+ def copy(parent: T.unsafe(nil), constant: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3886
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3904
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3913
+ def format(q); end
+
+ # [Node] the source of the constant
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3867
+ def parent; end
+end
+
+# ConstPathRef represents referencing a constant by a path.
+#
+# object::Const
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3929
+class SyntaxTree::ConstPathRef < ::SyntaxTree::Node
+ # @return [ConstPathRef] a new instance of ConstPathRef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3939
+ def initialize(parent:, constant:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3983
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3946
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3950
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3937
+ def comments; end
+
+ # [Const] the constant itself
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3934
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3954
+ def copy(parent: T.unsafe(nil), constant: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3950
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3968
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3977
+ def format(q); end
+
+ # [Node] the source of the constant
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3931
+ def parent; end
+end
+
+# ConstRef represents the name of the constant being used in a class or module
+# declaration.
+#
+# class Container
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3995
+class SyntaxTree::ConstRef < ::SyntaxTree::Node
+ # @return [ConstRef] a new instance of ConstRef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4002
+ def initialize(constant:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4037
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4008
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4012
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4000
+ def comments; end
+
+ # [Const] the constant itself
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3997
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4016
+ def copy(constant: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4012
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4029
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4033
+ def format(q); end
+end
+
+# If the predicate of a conditional or loop contains an assignment (in which
+# case we can't know for certain that that assignment doesn't impact the
+# statements inside the conditional) then we can't use the modifier form
+# and we must use the block form.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6232
+module SyntaxTree::ContainsAssignment
+ class << self
+ # source://syntax_tree//lib/syntax_tree/node.rb#6233
+ def call(parent); end
+ end
+end
+
+# The default indentation level for formatting. We allow changing this so
+# that Syntax Tree can format arbitrary parts of a document.
+#
+# source://syntax_tree//lib/syntax_tree.rb#57
+SyntaxTree::DEFAULT_INDENTATION = T.let(T.unsafe(nil), Integer)
+
+# This is the default print width when formatting. It can be overridden in the
+# CLI by passing the --print-width option or here in the API by passing the
+# optional second argument to ::format.
+#
+# source://syntax_tree//lib/syntax_tree.rb#49
+SyntaxTree::DEFAULT_PRINT_WIDTH = T.let(T.unsafe(nil), Integer)
+
+# This is the default ruby version that we're going to target for formatting.
+# It shouldn't really be changed except in very niche circumstances.
+#
+# source://syntax_tree//lib/syntax_tree.rb#53
+SyntaxTree::DEFAULT_RUBY_VERSION = T.let(T.unsafe(nil), SyntaxTree::Formatter::SemanticVersion)
+
+# This module provides shortcuts for creating AST nodes.
+#
+# source://syntax_tree//lib/syntax_tree/dsl.rb#5
+module SyntaxTree::DSL
+ # Create a new ARef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#40
+ def ARef(collection, index); end
+
+ # Create a new ARefField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#45
+ def ARefField(collection, index); end
+
+ # Create a new AliasNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#35
+ def AliasNode(left, right); end
+
+ # Create a new ArgBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#64
+ def ArgBlock(value); end
+
+ # Create a new ArgParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#54
+ def ArgParen(arguments); end
+
+ # Create a new ArgStar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#69
+ def ArgStar(value); end
+
+ # Create a new Args node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#59
+ def Args(parts); end
+
+ # Create a new ArgsForward node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#74
+ def ArgsForward; end
+
+ # Create a new ArrayLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#79
+ def ArrayLiteral(lbracket, contents); end
+
+ # Create a new AryPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#88
+ def AryPtn(constant, requireds, rest, posts); end
+
+ # Create a new Assign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#99
+ def Assign(target, value); end
+
+ # Create a new Assoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#104
+ def Assoc(key, value); end
+
+ # Create a new AssocSplat node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#109
+ def AssocSplat(value); end
+
+ # Create a new BEGINBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#7
+ def BEGINBlock(lbrace, statements); end
+
+ # Create a new Backref node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#114
+ def Backref(value); end
+
+ # Create a new Backtick node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#119
+ def Backtick(value); end
+
+ # Create a new BareAssocHash node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#124
+ def BareAssocHash(assocs); end
+
+ # Create a new Begin node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#129
+ def Begin(bodystmt); end
+
+ # Create a new Binary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#139
+ def Binary(left, operator, right); end
+
+ # Create a new BlockArg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#154
+ def BlockArg(name); end
+
+ # Create a new BlockNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#317
+ def BlockNode(opening, block_var, bodystmt); end
+
+ # Create a new BlockVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#149
+ def BlockVar(params, locals); end
+
+ # Create a new BodyStmt node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#159
+ def BodyStmt(statements, rescue_clause, else_keyword, else_clause, ensure_clause); end
+
+ # Create a new Break node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#177
+ def Break(arguments); end
+
+ # Create a new CHAR node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#16
+ def CHAR(value); end
+
+ # Create a new CVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#288
+ def CVar(value); end
+
+ # Create a new CallNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#182
+ def CallNode(receiver, operator, message, arguments); end
+
+ # Create a new Case node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#193
+ def Case(keyword, value, consequent); end
+
+ # Create a new ClassDeclaration node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#213
+ def ClassDeclaration(constant, superclass, bodystmt, location = T.unsafe(nil)); end
+
+ # Create a new Comma node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#228
+ def Comma(value); end
+
+ # Create a new Command node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#233
+ def Command(message, arguments, block, location = T.unsafe(nil)); end
+
+ # Create a new CommandCall node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#243
+ def CommandCall(receiver, operator, message, arguments, block); end
+
+ # Create a new Comment node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#255
+ def Comment(value, inline, location = T.unsafe(nil)); end
+
+ # Create a new Const node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#260
+ def Const(value); end
+
+ # Create a new ConstPathField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#265
+ def ConstPathField(parent, constant); end
+
+ # Create a new ConstPathRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#274
+ def ConstPathRef(parent, constant); end
+
+ # Create a new ConstRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#283
+ def ConstRef(constant); end
+
+ # Create a new DefNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#293
+ def DefNode(target, operator, name, params, bodystmt, location = T.unsafe(nil)); end
+
+ # Create a new Defined node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#312
+ def Defined(value); end
+
+ # Create a new DynaSymbol node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#337
+ def DynaSymbol(parts, quote); end
+
+ # Create a new ENDBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#21
+ def ENDBlock(lbrace, statements); end
+
+ # Create a new Else node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#342
+ def Else(keyword, statements); end
+
+ # Create a new Elsif node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#351
+ def Elsif(predicate, statements, consequent); end
+
+ # Create a new EmbDoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#361
+ def EmbDoc(value); end
+
+ # Create a new EmbExprBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#366
+ def EmbExprBeg(value); end
+
+ # Create a new EmbExprEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#371
+ def EmbExprEnd(value); end
+
+ # Create a new EmbVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#376
+ def EmbVar(value); end
+
+ # Create a new EndContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#30
+ def EndContent(value); end
+
+ # Create a new Ensure node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#381
+ def Ensure(keyword, statements); end
+
+ # Create a new ExcessedComma node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#390
+ def ExcessedComma(value); end
+
+ # Create a new Field node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#395
+ def Field(parent, operator, name); end
+
+ # Create a new FloatLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#405
+ def FloatLiteral(value); end
+
+ # Create a new FndPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#410
+ def FndPtn(constant, left, values, right); end
+
+ # Create a new For node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#421
+ def For(index, collection, statements); end
+
+ # Create a new GVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#431
+ def GVar(value); end
+
+ # Create a new HashLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#436
+ def HashLiteral(lbrace, assocs); end
+
+ # Create a new Heredoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#445
+ def Heredoc(beginning, ending, dedent, parts); end
+
+ # Create a new HeredocBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#456
+ def HeredocBeg(value); end
+
+ # Create a new HeredocEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#461
+ def HeredocEnd(value); end
+
+ # Create a new HshPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#466
+ def HshPtn(constant, keywords, keyword_rest); end
+
+ # Create a new IVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#521
+ def IVar(value); end
+
+ # Create a new Ident node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#476
+ def Ident(value); end
+
+ # Create a new IfNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#481
+ def IfNode(predicate, statements, consequent); end
+
+ # Create a new IfOp node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#491
+ def IfOp(predicate, truthy, falsy); end
+
+ # Create a new Imaginary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#501
+ def Imaginary(value); end
+
+ # Create a new In node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#506
+ def In(pattern, statements, consequent); end
+
+ # Create a new Int node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#516
+ def Int(value); end
+
+ # Create a new Kw node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#526
+ def Kw(value); end
+
+ # Create a new KwRestParam node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#531
+ def KwRestParam(name); end
+
+ # Create a new LBrace node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#560
+ def LBrace(value); end
+
+ # Create a new LBracket node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#565
+ def LBracket(value); end
+
+ # Create a new LParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#570
+ def LParen(value); end
+
+ # Create a new Label node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#536
+ def Label(value); end
+
+ # Create a new LabelEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#541
+ def LabelEnd(value); end
+
+ # Create a new Lambda node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#546
+ def Lambda(params, statements); end
+
+ # Create a new LambdaVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#555
+ def LambdaVar(params, locals); end
+
+ # Create a new MAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#575
+ def MAssign(target, value); end
+
+ # Create a new MLHS node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#585
+ def MLHS(parts, comma); end
+
+ # Create a new MLHSParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#590
+ def MLHSParen(contents, comma); end
+
+ # Create a new MRHS node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#608
+ def MRHS(parts); end
+
+ # Create a new MethodAddBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#580
+ def MethodAddBlock(call, block, location = T.unsafe(nil)); end
+
+ # Create a new ModuleDeclaration node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#599
+ def ModuleDeclaration(constant, bodystmt); end
+
+ # Create a new Next node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#613
+ def Next(arguments); end
+
+ # Create a new Not node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#892
+ def Not(statement, parentheses); end
+
+ # Create a new Op node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#618
+ def Op(value); end
+
+ # Create a new OpAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#623
+ def OpAssign(target, operator, value); end
+
+ # Create a new Params node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#633
+ def Params(requireds, optionals, rest, posts, keywords, keyword_rest, block); end
+
+ # Create a new Paren node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#647
+ def Paren(lparen, contents); end
+
+ # Create a new Period node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#652
+ def Period(value); end
+
+ # Create a new PinnedBegin node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#134
+ def PinnedBegin(statement); end
+
+ # Create a new PinnedVarRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#944
+ def PinnedVarRef(value); end
+
+ # Create a new Program node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#657
+ def Program(statements); end
+
+ # Create a new QSymbols node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#662
+ def QSymbols(beginning, elements); end
+
+ # Create a new QSymbolsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#671
+ def QSymbolsBeg(value); end
+
+ # Create a new QWords node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#676
+ def QWords(beginning, elements); end
+
+ # Create a new QWordsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#685
+ def QWordsBeg(value); end
+
+ # Create a new RAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#203
+ def RAssign(value, operator, pattern); end
+
+ # Create a new RBrace node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#695
+ def RBrace(value); end
+
+ # Create a new RBracket node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#700
+ def RBracket(value); end
+
+ # Create a new RParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#783
+ def RParen(value); end
+
+ # Create a new RangeNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#327
+ def RangeNode(left, operator, right); end
+
+ # Create a new RationalLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#690
+ def RationalLiteral(value); end
+
+ # Create a new Redo node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#705
+ def Redo; end
+
+ # Create a new RegexpBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#719
+ def RegexpBeg(value); end
+
+ # Create a new RegexpContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#710
+ def RegexpContent(beginning, parts); end
+
+ # Create a new RegexpEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#724
+ def RegexpEnd(value); end
+
+ # Create a new RegexpLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#729
+ def RegexpLiteral(beginning, ending, parts); end
+
+ # Create a new Rescue node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#748
+ def Rescue(keyword, exception, statements, consequent); end
+
+ # Create a new RescueEx node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#739
+ def RescueEx(exceptions, variable); end
+
+ # Create a new RescueMod node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#759
+ def RescueMod(statement, value); end
+
+ # Create a new RestParam node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#768
+ def RestParam(name); end
+
+ # Create a new Retry node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#773
+ def Retry; end
+
+ # Create a new ReturnNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#778
+ def ReturnNode(arguments); end
+
+ # Create a new SClass node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#788
+ def SClass(target, bodystmt); end
+
+ # Create a new Statements node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#793
+ def Statements(body); end
+
+ # Create a new StringConcat node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#803
+ def StringConcat(left, right); end
+
+ # Create a new StringContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#798
+ def StringContent(parts); end
+
+ # Create a new StringDVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#808
+ def StringDVar(variable); end
+
+ # Create a new StringEmbExpr node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#813
+ def StringEmbExpr(statements); end
+
+ # Create a new StringLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#818
+ def StringLiteral(parts, quote); end
+
+ # Create a new Super node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#823
+ def Super(arguments); end
+
+ # Create a new SymBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#828
+ def SymBeg(value); end
+
+ # Create a new SymbolContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#833
+ def SymbolContent(value); end
+
+ # Create a new SymbolLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#838
+ def SymbolLiteral(value); end
+
+ # Create a new Symbols node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#843
+ def Symbols(beginning, elements); end
+
+ # Create a new SymbolsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#852
+ def SymbolsBeg(value); end
+
+ # Create a new TLamBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#862
+ def TLamBeg(value); end
+
+ # Create a new TLambda node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#857
+ def TLambda(value); end
+
+ # Create a new TStringBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#877
+ def TStringBeg(value); end
+
+ # Create a new TStringContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#882
+ def TStringContent(value); end
+
+ # Create a new TStringEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#887
+ def TStringEnd(value); end
+
+ # Create a new TopConstField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#867
+ def TopConstField(constant); end
+
+ # Create a new TopConstRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#872
+ def TopConstRef(constant); end
+
+ # Create a new Unary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#901
+ def Unary(operator, statement); end
+
+ # Create a new Undef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#910
+ def Undef(symbols); end
+
+ # Create a new UnlessNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#915
+ def UnlessNode(predicate, statements, consequent); end
+
+ # Create a new UntilNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#925
+ def UntilNode(predicate, statements); end
+
+ # Create a new VCall node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#949
+ def VCall(value); end
+
+ # Create a new VarField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#934
+ def VarField(value); end
+
+ # Create a new VarRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#939
+ def VarRef(value); end
+
+ # Create a new VoidStmt node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#954
+ def VoidStmt; end
+
+ # Create a new When node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#959
+ def When(arguments, statements, consequent); end
+
+ # Create a new WhileNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#969
+ def WhileNode(predicate, statements); end
+
+ # Create a new Word node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#978
+ def Word(parts); end
+
+ # Create a new Words node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#983
+ def Words(beginning, elements); end
+
+ # Create a new WordsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#992
+ def WordsBeg(value); end
+
+ # Create a new XString node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#997
+ def XString(parts); end
+
+ # Create a new XStringLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#1002
+ def XStringLiteral(parts); end
+
+ # Create a new YieldNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#1007
+ def YieldNode(arguments); end
+
+ # Create a new ZSuper node.
+ #
+ # source://syntax_tree//lib/syntax_tree/dsl.rb#1012
+ def ZSuper; end
+end
+
+# Provides the ability to index source files into a database, then query for
+# the nodes.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#6
+module SyntaxTree::Database; end
+
+# Query for the attributes of a node, optionally also filtering by type.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#99
+class SyntaxTree::Database::AttrQuery
+ # @return [AttrQuery] a new instance of AttrQuery
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#102
+ def initialize(type, attrs); end
+
+ # Returns the value of attribute attrs.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#100
+ def attrs; end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#107
+ def each(database, &block); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#100
+ def type; end
+end
+
+# source://syntax_tree//lib/syntax_tree/database.rb#276
+class SyntaxTree::Database::Connection
+ # @return [Connection] a new instance of Connection
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#279
+ def initialize(raw_connection); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#283
+ def execute(query, binds = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#287
+ def index_file(filepath); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#292
+ def last_insert_row_id; end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#296
+ def prepare; end
+
+ # Returns the value of attribute raw_connection.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#277
+ def raw_connection; end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#326
+ def search(query); end
+end
+
+# source://syntax_tree//lib/syntax_tree/database.rb#7
+class SyntaxTree::Database::IndexingVisitor < ::SyntaxTree::FieldVisitor
+ # @return [IndexingVisitor] a new instance of IndexingVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#10
+ def initialize(database, filepath); end
+
+ # Returns the value of attribute database.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#8
+ def database; end
+
+ # Returns the value of attribute filepath.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#8
+ def filepath; end
+
+ # Returns the value of attribute node_id.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#8
+ def node_id; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#18
+ def comments(node); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#21
+ def field(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#31
+ def list(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#41
+ def node(node, _name); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#67
+ def pairs(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#64
+ def text(name, value); end
+end
+
+# Query for the results of either query.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#136
+class SyntaxTree::Database::OrQuery
+ # @return [OrQuery] a new instance of OrQuery
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#139
+ def initialize(left, right); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#144
+ def each(database, &block); end
+
+ # Returns the value of attribute left.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#137
+ def left; end
+
+ # Returns the value of attribute right.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#137
+ def right; end
+end
+
+# A pattern matching expression that will be compiled into a query.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#166
+class SyntaxTree::Database::Pattern
+ # @return [Pattern] a new instance of Pattern
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#172
+ def initialize(query); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#176
+ def compile; end
+
+ # Returns the value of attribute query.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#170
+ def query; end
+
+ private
+
+ # Shortcut for combining two queries into one that returns the results of
+ # if either query matches.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#195
+ def combine_or(left, right); end
+
+ # in foo | bar
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#200
+ def compile_binary(node); end
+
+ # in Ident
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#207
+ def compile_const(node); end
+
+ # in SyntaxTree::Ident
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#219
+ def compile_const_path_ref(node); end
+
+ # @raise [CompilationError]
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#189
+ def compile_error(node); end
+
+ # in Ident[value: String]
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#234
+ def compile_hshptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#258
+ def compile_node(node); end
+
+ # in Foo
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#248
+ def compile_var_ref(node); end
+end
+
+# source://syntax_tree//lib/syntax_tree/database.rb#167
+class SyntaxTree::Database::Pattern::CompilationError < ::StandardError; end
+
+# A lazy query result.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#151
+class SyntaxTree::Database::QueryResult
+ # @return [QueryResult] a new instance of QueryResult
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#154
+ def initialize(database, query); end
+
+ # Returns the value of attribute database.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#152
+ def database; end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#159
+ def each(&block); end
+
+ # Returns the value of attribute query.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#152
+ def query; end
+end
+
+# Query for a specific type of node.
+#
+# source://syntax_tree//lib/syntax_tree/database.rb#85
+class SyntaxTree::Database::TypeQuery
+ # @return [TypeQuery] a new instance of TypeQuery
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#88
+ def initialize(type); end
+
+ # source://syntax_tree//lib/syntax_tree/database.rb#92
+ def each(database, &block); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/database.rb#86
+ def type; end
+end
+
+# Def represents defining a regular method on the current self object.
+#
+# def method(param) result end
+# def object.method(param) result end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4098
+class SyntaxTree::DefNode < ::SyntaxTree::Node
+ # @return [DefNode] a new instance of DefNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4117
+ def initialize(target:, operator:, name:, params:, bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4217
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4127
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4230
+ def arity; end
+
+ # [BodyStmt | Node] the expressions to be executed by the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4112
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4131
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4115
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4135
+ def copy(target: T.unsafe(nil), operator: T.unsafe(nil), name: T.unsafe(nil), params: T.unsafe(nil), bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4131
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4159
+ def deconstruct_keys(_keys); end
+
+ # Returns true if the method was found in the source in the "endless" form,
+ # i.e. where the method body is defined using the `=` operator after the
+ # method name and parameters.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4226
+ def endless?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4171
+ def format(q); end
+
+ # [Backtick | Const | Ident | Kw | Op] the name of the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4106
+ def name; end
+
+ # [nil | Op | Period] the operator being used to declare the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4103
+ def operator; end
+
+ # [nil | Params | Paren] the parameter declaration for the method
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4109
+ def params; end
+
+ # [nil | Node] the target where the method is being defined
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4100
+ def target; end
+end
+
+# Defined represents the use of the +defined?+ operator. It can be used with
+# and without parentheses.
+#
+# defined?(variable)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4249
+class SyntaxTree::Defined < ::SyntaxTree::Node
+ # @return [Defined] a new instance of Defined
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4256
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4299
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4262
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4266
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4254
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4270
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4266
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4283
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4287
+ def format(q); end
+
+ # [Node] the value being sent to the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4251
+ def value; end
+end
+
+# DynaSymbol represents a symbol literal that uses quotes to dynamically
+# define its value.
+#
+# :"#{variable}"
+#
+# They can also be used as a special kind of dynamic hash key, as in:
+#
+# { "#{key}": value }
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4663
+class SyntaxTree::DynaSymbol < ::SyntaxTree::Node
+ # @return [DynaSymbol] a new instance of DynaSymbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4674
+ def initialize(parts:, quote:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4736
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4681
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4685
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4672
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4689
+ def copy(parts: T.unsafe(nil), quote: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4685
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4703
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4707
+ def format(q); end
+
+ # [Array[ StringDVar | StringEmbExpr | TStringContent ]] the parts of the
+ # dynamic symbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4666
+ def parts; end
+
+ # [nil | String] the quote used to delimit the dynamic symbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4669
+ def quote; end
+
+ private
+
+ # Here we determine the quotes to use for a dynamic symbol. It's bound by a
+ # lot of rules because it could be in many different contexts with many
+ # different kinds of escaping.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4746
+ def quotes(q); end
+end
+
+# ENDBlock represents the use of the +END+ keyword, which hooks into the
+# lifecycle of the interpreter. Whatever is inside the block will get executed
+# when the program ends.
+#
+# END {
+# }
+#
+# Interestingly, the END keyword doesn't allow the do and end keywords for the
+# block. Only braces are permitted.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#310
+class SyntaxTree::ENDBlock < ::SyntaxTree::Node
+ # @return [ENDBlock] a new instance of ENDBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#320
+ def initialize(lbrace:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#371
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#327
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#331
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#318
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#335
+ def copy(lbrace: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#331
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#349
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#358
+ def format(q); end
+
+ # [LBrace] the left brace that is seen after the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#312
+ def lbrace; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#315
+ def statements; end
+end
+
+# Else represents the end of an +if+, +unless+, or +case+ chain.
+#
+# if variable
+# else
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4792
+class SyntaxTree::Else < ::SyntaxTree::Node
+ # @return [Else] a new instance of Else
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4802
+ def initialize(keyword:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4853
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4809
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4813
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4800
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4817
+ def copy(keyword: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4813
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4831
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4840
+ def format(q); end
+
+ # [Kw] the else keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4794
+ def keyword; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4797
+ def statements; end
+end
+
+# Elsif represents another clause in an +if+ or +unless+ chain.
+#
+# if variable
+# elsif other_variable
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4865
+class SyntaxTree::Elsif < ::SyntaxTree::Node
+ # @return [Elsif] a new instance of Elsif
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4878
+ def initialize(predicate:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4942
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4886
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4890
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4876
+ def comments; end
+
+ # [nil | Elsif | Else] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4873
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4894
+ def copy(predicate: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4890
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4909
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4919
+ def format(q); end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4867
+ def predicate; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4870
+ def statements; end
+end
+
+# EmbDoc represents a multi-line comment.
+#
+# =begin
+# first line
+# second line
+# =end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4955
+class SyntaxTree::EmbDoc < ::SyntaxTree::Node
+ # @return [EmbDoc] a new instance of EmbDoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4959
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5027
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4995
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4999
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4991
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5003
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4999
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5012
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5016
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4987
+ def ignore?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4983
+ def inline?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4967
+ def leading!; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4971
+ def leading?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4975
+ def trailing!; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4979
+ def trailing?; end
+
+ # [String] the contents of the comment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4957
+ def value; end
+end
+
+# EmbExprBeg represents the beginning token for using interpolation inside of
+# a parent node that accepts string content (like a string or regular
+# expression).
+#
+# "Hello, #{person}!"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5038
+class SyntaxTree::EmbExprBeg < ::SyntaxTree::Node
+ # @return [EmbExprBeg] a new instance of EmbExprBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5042
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5068
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5047
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5051
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5055
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5051
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5064
+ def deconstruct_keys(_keys); end
+
+ # [String] the #{ used in the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5040
+ def value; end
+end
+
+# EmbExprEnd represents the ending token for using interpolation inside of a
+# parent node that accepts string content (like a string or regular
+# expression).
+#
+# "Hello, #{person}!"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5079
+class SyntaxTree::EmbExprEnd < ::SyntaxTree::Node
+ # @return [EmbExprEnd] a new instance of EmbExprEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5083
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5109
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5088
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5092
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5096
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5092
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5105
+ def deconstruct_keys(_keys); end
+
+ # [String] the } used in the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5081
+ def value; end
+end
+
+# EmbVar represents the use of shorthand interpolation for an instance, class,
+# or global variable into a parent node that accepts string content (like a
+# string or regular expression).
+#
+# "#@variable"
+#
+# In the example above, an EmbVar node represents the # because it forces
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5122
+class SyntaxTree::EmbVar < ::SyntaxTree::Node
+ # @return [EmbVar] a new instance of EmbVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5126
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5152
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5131
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5135
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5139
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5135
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5148
+ def deconstruct_keys(_keys); end
+
+ # [String] the # used in the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5124
+ def value; end
+end
+
+# EndContent represents the use of __END__ syntax, which allows individual
+# scripts to keep content after the main ruby code that can be read through
+# the DATA constant.
+#
+# puts DATA.read
+#
+# __END__
+# some other content that is not executed by the program
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#386
+class SyntaxTree::EndContent < ::SyntaxTree::Node
+ # @return [EndContent] a new instance of EndContent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#393
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#442
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#399
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#403
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#391
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#407
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#403
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#420
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#424
+ def format(q); end
+
+ # [String] the content after the script
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#388
+ def value; end
+end
+
+# Ensure represents the use of the +ensure+ keyword and its subsequent
+# statements.
+#
+# begin
+# ensure
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5164
+class SyntaxTree::Ensure < ::SyntaxTree::Node
+ # @return [Ensure] a new instance of Ensure
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5174
+ def initialize(keyword:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5223
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5181
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5185
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5172
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5189
+ def copy(keyword: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5185
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5203
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5212
+ def format(q); end
+
+ # [Kw] the ensure keyword that began this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5166
+ def keyword; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5169
+ def statements; end
+end
+
+# ExcessedComma represents a trailing comma in a list of block parameters. It
+# changes the block parameters such that they will destructure.
+#
+# [[1, 2, 3], [2, 3, 4]].each do |first, second,|
+# end
+#
+# In the above example, an ExcessedComma node would appear in the third
+# position of the Params node that is used to declare that block. The third
+# position typically represents a rest-type parameter, but in this case is
+# used to indicate that a trailing comma was used.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5239
+class SyntaxTree::ExcessedComma < ::SyntaxTree::Node
+ # @return [ExcessedComma] a new instance of ExcessedComma
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5246
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5281
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5252
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5256
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5244
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5260
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5256
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5273
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5277
+ def format(q); end
+
+ # [String] the comma
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5241
+ def value; end
+end
+
+# Field is always the child of an assignment. It represents assigning to a
+# “field” on an object.
+#
+# object.variable = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5291
+class SyntaxTree::Field < ::SyntaxTree::Node
+ # @return [Field] a new instance of Field
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5304
+ def initialize(parent:, operator:, name:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5354
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5312
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5316
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5302
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5321
+ def copy(parent: T.unsafe(nil), operator: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5316
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5336
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5346
+ def format(q); end
+
+ # [Const | Ident] the name of the field being assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5299
+ def name; end
+
+ # [:"::" | Op | Period] the operator being used for the assignment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5296
+ def operator; end
+
+ # [Node] the parent object that owns the field being assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5293
+ def parent; end
+end
+
+# This is the parent class of a lot of built-in visitors for Syntax Tree. It
+# reflects visiting each of the fields on every node in turn. It itself does
+# not do anything with these fields, it leaves that behavior up to the
+# subclass to implement.
+#
+# In order to properly use this class, you will need to subclass it and
+# implement #comments, #field, #list, #node, #pairs, and #text. Those are
+# documented here.
+#
+# == comments(node)
+#
+# This accepts the node that is being visited and does something depending on
+# the comments attached to the node.
+#
+# == field(name, value)
+#
+# This accepts the name of the field being visited as a string (like "value")
+# and the actual value of that field. The value can be a subclass of Node or
+# any other type that can be held within the tree.
+#
+# == list(name, values)
+#
+# This accepts the name of the field being visited as well as a list of
+# values. This is used, for example, when visiting something like the body of
+# a Statements node.
+#
+# == node(name, node)
+#
+# This is the parent serialization method for each node. It is called with the
+# node itself, as well as the type of the node as a string. The type is an
+# internally used value that usually resembles the name of the ripper event
+# that generated the node. The method should yield to the given block which
+# then calls through to visit each of the fields on the node.
+#
+# == text(name, value)
+#
+# This accepts the name of the field being visited as well as a string value
+# representing the value of the field.
+#
+# == pairs(name, values)
+#
+# This accepts the name of the field being visited as well as a list of pairs
+# that represent the value of the field. It is used only in a couple of
+# circumstances, like when visiting the list of optional parameters defined on
+# a method.
+#
+# source://syntax_tree//lib/syntax_tree/field_visitor.rb#50
+class SyntaxTree::FieldVisitor < ::SyntaxTree::BasicVisitor
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#163
+ def visit_BEGIN(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#245
+ def visit_CHAR(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#342
+ def visit_END(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#1018
+ def visit___end__(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#68
+ def visit_alias(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#52
+ def visit_aref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#60
+ def visit_aref_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#76
+ def visit_arg_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#83
+ def visit_arg_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#90
+ def visit_arg_star(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#97
+ def visit_args(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#104
+ def visit_args_forward(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#108
+ def visit_array(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#115
+ def visit_aryptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#125
+ def visit_assign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#133
+ def visit_assoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#141
+ def visit_assoc_splat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#148
+ def visit_backref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#152
+ def visit_backtick(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#156
+ def visit_bare_assoc_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#170
+ def visit_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#177
+ def visit_binary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#186
+ def visit_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#201
+ def visit_block_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#194
+ def visit_blockarg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#209
+ def visit_bodystmt(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#219
+ def visit_break(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#226
+ def visit_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#236
+ def visit_case(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#249
+ def visit_class(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#258
+ def visit_comma(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#262
+ def visit_command(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#271
+ def visit_command_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#282
+ def visit_comment(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#286
+ def visit_const(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#290
+ def visit_const_path_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#298
+ def visit_const_path_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#306
+ def visit_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#313
+ def visit_cvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#317
+ def visit_def(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#328
+ def visit_defined(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#335
+ def visit_dyna_symbol(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#349
+ def visit_else(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#356
+ def visit_elsif(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#365
+ def visit_embdoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#369
+ def visit_embexpr_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#373
+ def visit_embexpr_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#377
+ def visit_embvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#381
+ def visit_ensure(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#388
+ def visit_excessed_comma(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#392
+ def visit_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#401
+ def visit_float(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#405
+ def visit_fndptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#415
+ def visit_for(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#424
+ def visit_gvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#428
+ def visit_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#435
+ def visit_heredoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#442
+ def visit_heredoc_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#446
+ def visit_heredoc_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#450
+ def visit_hshptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#459
+ def visit_ident(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#463
+ def visit_if(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#472
+ def visit_if_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#481
+ def visit_imaginary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#485
+ def visit_in(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#494
+ def visit_int(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#498
+ def visit_ivar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#502
+ def visit_kw(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#506
+ def visit_kwrest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#513
+ def visit_label(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#517
+ def visit_label_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#521
+ def visit_lambda(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#529
+ def visit_lambda_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#537
+ def visit_lbrace(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#541
+ def visit_lbracket(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#545
+ def visit_lparen(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#549
+ def visit_massign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#557
+ def visit_method_add_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#565
+ def visit_mlhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#572
+ def visit_mlhs_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#579
+ def visit_module(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#587
+ def visit_mrhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#594
+ def visit_next(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#601
+ def visit_not(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#608
+ def visit_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#612
+ def visit_opassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#621
+ def visit_params(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#634
+ def visit_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#641
+ def visit_period(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#645
+ def visit_pinned_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#652
+ def visit_pinned_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#659
+ def visit_program(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#666
+ def visit_qsymbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#673
+ def visit_qsymbols_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#677
+ def visit_qwords(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#684
+ def visit_qwords_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#688
+ def visit_range(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#697
+ def visit_rassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#706
+ def visit_rational(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#710
+ def visit_rbrace(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#714
+ def visit_rbracket(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#718
+ def visit_redo(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#722
+ def visit_regexp_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#726
+ def visit_regexp_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#730
+ def visit_regexp_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#734
+ def visit_regexp_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#742
+ def visit_rescue(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#751
+ def visit_rescue_ex(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#759
+ def visit_rescue_mod(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#767
+ def visit_rest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#774
+ def visit_retry(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#778
+ def visit_return(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#785
+ def visit_rparen(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#789
+ def visit_sclass(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#797
+ def visit_statements(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#804
+ def visit_string_concat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#812
+ def visit_string_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#816
+ def visit_string_dvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#823
+ def visit_string_embexpr(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#830
+ def visit_string_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#837
+ def visit_super(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#844
+ def visit_symbeg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#848
+ def visit_symbol_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#852
+ def visit_symbol_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#859
+ def visit_symbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#866
+ def visit_symbols_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#870
+ def visit_tlambda(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#874
+ def visit_tlambeg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#878
+ def visit_top_const_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#885
+ def visit_top_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#892
+ def visit_tstring_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#896
+ def visit_tstring_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#900
+ def visit_tstring_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#904
+ def visit_unary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#912
+ def visit_undef(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#919
+ def visit_unless(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#928
+ def visit_until(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#936
+ def visit_var_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#943
+ def visit_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#950
+ def visit_vcall(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#957
+ def visit_void_stmt(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#961
+ def visit_when(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#970
+ def visit_while(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#978
+ def visit_word(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#985
+ def visit_words(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#992
+ def visit_words_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#996
+ def visit_xstring(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#1000
+ def visit_xstring_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#1007
+ def visit_yield(node); end
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#1014
+ def visit_zsuper(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/field_visitor.rb#1025
+ def visit_token(node, type); end
+end
+
+# FloatLiteral represents a floating point number literal.
+#
+# 1.0
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5364
+class SyntaxTree::FloatLiteral < ::SyntaxTree::Node
+ # @return [FloatLiteral] a new instance of FloatLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5371
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5406
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5377
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5381
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5369
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5385
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5381
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5398
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5402
+ def format(q); end
+
+ # [String] the value of the floating point number literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5366
+ def value; end
+end
+
+# Formats either a Break, Next, or Return node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#2438
+class SyntaxTree::FlowControlFormatter
+ # @return [FlowControlFormatter] a new instance of FlowControlFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2445
+ def initialize(keyword, node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2450
+ def format(q); end
+
+ # [String] the keyword to print
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2440
+ def keyword; end
+
+ # [Break | Next | Return] the node being formatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2443
+ def node; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2599
+ def format_arguments(q, opening, closing); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2589
+ def format_array_contents(q, array); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#2609
+ def skip_parens?(node); end
+end
+
+# FndPtn represents matching against a pattern where you find a pattern in an
+# array using the Ruby 3.0+ pattern matching syntax.
+#
+# case value
+# in [*, 7, *]
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5418
+class SyntaxTree::FndPtn < ::SyntaxTree::Node
+ # @return [FndPtn] a new instance of FndPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5435
+ def initialize(constant:, left:, values:, right:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5504
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5444
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5448
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5433
+ def comments; end
+
+ # [nil | VarRef | ConstPathRef] the optional constant wrapper
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5420
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5452
+ def copy(constant: T.unsafe(nil), left: T.unsafe(nil), values: T.unsafe(nil), right: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5448
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5468
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5479
+ def format(q); end
+
+ # [VarField] the splat on the left-hand side
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5423
+ def left; end
+
+ # [VarField] the splat on the right-hand side
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5430
+ def right; end
+
+ # [Array[ Node ]] the list of positional expressions in the pattern that
+ # are being matched
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5427
+ def values; end
+end
+
+# For represents using a +for+ loop.
+#
+# for value in list do
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5516
+class SyntaxTree::For < ::SyntaxTree::Node
+ # @return [For] a new instance of For
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5530
+ def initialize(index:, collection:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5590
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5538
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5542
+ def child_nodes; end
+
+ # [Node] the object being enumerated in the loop
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5522
+ def collection; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5528
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5546
+ def copy(index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5542
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5561
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5571
+ def format(q); end
+
+ # [MLHS | VarField] the variable declaration being used to
+ # pull values out of the object being enumerated
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5519
+ def index; end
+
+ # [Statements] the statements to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5525
+ def statements; end
+end
+
+# A slightly enhanced PP that knows how to format recursively including
+# comments.
+#
+# source://syntax_tree//lib/syntax_tree/formatter.rb#6
+class SyntaxTree::Formatter < ::PrettierPrint
+ # @return [Formatter] a new instance of Formatter
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#95
+ def initialize(source, *args, options: T.unsafe(nil)); end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def disable_auto_ternary; end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def disable_auto_ternary?; end
+
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#115
+ def format(node, stackable: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#175
+ def format_each(nodes); end
+
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#179
+ def grandparent; end
+
+ # This is a simplified version of prettyprint's group. It doesn't provide
+ # any of the more advanced options because we don't need them and they take
+ # up expensive computation time.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#194
+ def group; end
+
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#183
+ def parent; end
+
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#187
+ def parents; end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def quote; end
+
+ # A similar version to the super, except that it calls back into the
+ # separator proc with the instance of `self`.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#208
+ def seplist(list, sep = T.unsafe(nil), iter_method = T.unsafe(nil)); end
+
+ # Returns the value of attribute source.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#83
+ def source; end
+
+ # Returns the value of attribute stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#83
+ def stack; end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def target_ruby_version; end
+
+ # This is a much simplified version of prettyprint's text. It avoids
+ # calculating width by pushing the string directly onto the target.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#224
+ def text(string); end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def trailing_comma; end
+
+ # These options are overridden in plugins to we need to make sure they are
+ # available here.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#87
+ def trailing_comma?; end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#108
+ def format(source, node, base_indentation = T.unsafe(nil)); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/formatter.rb#80
+SyntaxTree::Formatter::COMMENT_PRIORITY = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/formatter.rb#81
+SyntaxTree::Formatter::HEREDOC_PRIORITY = T.let(T.unsafe(nil), Integer)
+
+# We want to minimize as much as possible the number of options that are
+# available in syntax tree. For the most part, if users want non-default
+# formatting, they should override the format methods on the specific nodes
+# themselves. However, because of some history with prettier and the fact
+# that folks have become entrenched in their ways, we decided to provide a
+# small amount of configurability.
+#
+# source://syntax_tree//lib/syntax_tree/formatter.rb#23
+class SyntaxTree::Formatter::Options
+ # @return [Options] a new instance of Options
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#29
+ def initialize(quote: T.unsafe(nil), trailing_comma: T.unsafe(nil), disable_auto_ternary: T.unsafe(nil), target_ruby_version: T.unsafe(nil)); end
+
+ # Returns the value of attribute disable_auto_ternary.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#24
+ def disable_auto_ternary; end
+
+ # Returns the value of attribute quote.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#24
+ def quote; end
+
+ # Returns the value of attribute target_ruby_version.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#24
+ def target_ruby_version; end
+
+ # Returns the value of attribute trailing_comma.
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#24
+ def trailing_comma; end
+end
+
+# Unfortunately, Gem::Version.new is not ractor-safe because it performs
+# global caching using a class variable. This works around that by just
+# setting the instance variables directly.
+#
+# source://syntax_tree//lib/syntax_tree/formatter.rb#10
+class SyntaxTree::Formatter::SemanticVersion < ::Gem::Version
+ # @return [SemanticVersion] a new instance of SemanticVersion
+ #
+ # source://syntax_tree//lib/syntax_tree/formatter.rb#11
+ def initialize(version); end
+end
+
+# GVar represents a global variable literal.
+#
+# $variable
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5600
+class SyntaxTree::GVar < ::SyntaxTree::Node
+ # @return [GVar] a new instance of GVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5607
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5642
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5613
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5617
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5605
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5621
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5617
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5634
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5638
+ def format(q); end
+
+ # [String] the name of the global variable
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5602
+ def value; end
+end
+
+# This holds references to objects that respond to both #parse and #format
+# so that we can use them in the CLI.
+#
+# source://syntax_tree//lib/syntax_tree.rb#43
+SyntaxTree::HANDLERS = T.let(T.unsafe(nil), Hash)
+
+# This module is responsible for formatting the assocs contained within a
+# hash or bare hash. It first determines if every key in the hash can use
+# labels. If it can, it uses labels. Otherwise it uses hash rockets.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1728
+module SyntaxTree::HashKeyFormatter
+ class << self
+ # source://syntax_tree//lib/syntax_tree/node.rb#1786
+ def for(container); end
+ end
+end
+
+# When formatting a single assoc node without the context of the parent
+# hash, this formatter is used. It uses whatever is present in the node,
+# because there is nothing to be consistent with.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1775
+class SyntaxTree::HashKeyFormatter::Identity
+ # source://syntax_tree//lib/syntax_tree/node.rb#1776
+ def format_key(q, key); end
+end
+
+# Formats the keys of a hash literal using labels.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1730
+class SyntaxTree::HashKeyFormatter::Labels
+ # source://syntax_tree//lib/syntax_tree/node.rb#1733
+ def format_key(q, key); end
+end
+
+# source://syntax_tree//lib/syntax_tree/node.rb#1731
+SyntaxTree::HashKeyFormatter::Labels::LABEL = T.let(T.unsafe(nil), Regexp)
+
+# Formats the keys of a hash literal using hash rockets.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1756
+class SyntaxTree::HashKeyFormatter::Rockets
+ # source://syntax_tree//lib/syntax_tree/node.rb#1757
+ def format_key(q, key); end
+end
+
+# HashLiteral represents a hash literal.
+#
+# { key => value }
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5651
+class SyntaxTree::HashLiteral < ::SyntaxTree::Node
+ # @return [HashLiteral] a new instance of HashLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5687
+ def initialize(lbrace:, assocs:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5728
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5694
+ def accept(visitor); end
+
+ # [Array[ Assoc | AssocSplat ]] the optional contents of the hash
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5682
+ def assocs; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5698
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5685
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5702
+ def copy(lbrace: T.unsafe(nil), assocs: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5698
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5716
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5720
+ def format(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5733
+ def format_key(q, key); end
+
+ # [LBrace] the left brace that opens this hash
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5679
+ def lbrace; end
+
+ private
+
+ # If we have an empty hash that contains only comments, then we're going
+ # to do some special printing to ensure they get indented correctly.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5741
+ def empty_with_comments?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5745
+ def format_contents(q); end
+end
+
+# This is a special formatter used if the hash literal contains no values
+# but _does_ contain comments. In this case we do some special formatting to
+# make sure the comments gets indented properly.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5655
+class SyntaxTree::HashLiteral::EmptyWithCommentsFormatter
+ # @return [EmptyWithCommentsFormatter] a new instance of EmptyWithCommentsFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5659
+ def initialize(lbrace); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5663
+ def format(q); end
+
+ # [LBrace] the opening brace
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5657
+ def lbrace; end
+end
+
+# Heredoc represents a heredoc string literal.
+#
+# <<~DOC
+# contents
+# DOC
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5774
+class SyntaxTree::Heredoc < ::SyntaxTree::Node
+ # @return [Heredoc] a new instance of Heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5791
+ def initialize(beginning:, location:, ending: T.unsafe(nil), dedent: T.unsafe(nil), parts: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5873
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5800
+ def accept(visitor); end
+
+ # [HeredocBeg] the opening of the heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5776
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5804
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5789
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5808
+ def copy(beginning: T.unsafe(nil), location: T.unsafe(nil), ending: T.unsafe(nil), parts: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5804
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5823
+ def deconstruct_keys(_keys); end
+
+ # [Integer] how far to dedent the heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5782
+ def dedent; end
+
+ # [HeredocEnd] the ending of the heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5779
+ def ending; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5838
+ def format(q); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # heredoc string literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5786
+ def parts; end
+end
+
+# This is a very specific behavior where you want to force a newline, but
+# don't want to force the break parent.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5835
+SyntaxTree::Heredoc::SEPARATOR = T.let(T.unsafe(nil), PrettierPrint::Breakable)
+
+# HeredocBeg represents the beginning declaration of a heredoc.
+#
+# <<~DOC
+# contents
+# DOC
+#
+# In the example above the HeredocBeg node represents <<~DOC.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5886
+class SyntaxTree::HeredocBeg < ::SyntaxTree::Node
+ # @return [HeredocBeg] a new instance of HeredocBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5893
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5928
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5899
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5903
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5891
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5907
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5903
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5920
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5924
+ def format(q); end
+
+ # [String] the opening declaration of the heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5888
+ def value; end
+end
+
+# HeredocEnd represents the closing declaration of a heredoc.
+#
+# <<~DOC
+# contents
+# DOC
+#
+# In the example above the HeredocEnd node represents the closing DOC.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5940
+class SyntaxTree::HeredocEnd < ::SyntaxTree::Node
+ # @return [HeredocEnd] a new instance of HeredocEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5947
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5982
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5953
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5957
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5945
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5961
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5957
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5974
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#5978
+ def format(q); end
+
+ # [String] the closing declaration of the heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5942
+ def value; end
+end
+
+# HshPtn represents matching against a hash pattern using the Ruby 2.7+
+# pattern matching syntax.
+#
+# case value
+# in { key: }
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5994
+class SyntaxTree::HshPtn < ::SyntaxTree::Node
+ # @return [HshPtn] a new instance of HshPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6054
+ def initialize(constant:, keywords:, keyword_rest:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6147
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6062
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6066
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6052
+ def comments; end
+
+ # [nil | VarRef | ConstPathRef] the optional constant wrapper
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6042
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6070
+ def copy(constant: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6066
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6085
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6095
+ def format(q); end
+
+ # [nil | VarField] an optional parameter to gather up all remaining keywords
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6049
+ def keyword_rest; end
+
+ # [Array[ [DynaSymbol | Label, nil | Node] ]] the set of tuples
+ # representing the keywords that should be matched against in the pattern
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6046
+ def keywords; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6158
+ def format_contents(q, parts, nested); end
+end
+
+# Formats a key-value pair in a hash pattern. The value is optional.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5996
+class SyntaxTree::HshPtn::KeywordFormatter
+ # @return [KeywordFormatter] a new instance of KeywordFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6003
+ def initialize(key, value); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6008
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6012
+ def format(q); end
+
+ # [Label] the keyword being used
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#5998
+ def key; end
+
+ # [Node] the optional value for the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6001
+ def value; end
+end
+
+# Formats the optional double-splat from the pattern.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6023
+class SyntaxTree::HshPtn::KeywordRestFormatter
+ # @return [KeywordRestFormatter] a new instance of KeywordRestFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6027
+ def initialize(keyword_rest); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6031
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6035
+ def format(q); end
+
+ # [VarField] the parameter that matches the remaining keywords
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6025
+ def keyword_rest; end
+end
+
+# IVar represents an instance variable literal.
+#
+# @variable
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6878
+class SyntaxTree::IVar < ::SyntaxTree::Node
+ # @return [IVar] a new instance of IVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6885
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6920
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6891
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6895
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6883
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6899
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6895
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6912
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6916
+ def format(q); end
+
+ # [String] the name of the instance variable
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6880
+ def value; end
+end
+
+# Ident represents an identifier anywhere in code. It can represent a very
+# large number of things, depending on where it is in the syntax tree.
+#
+# value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6181
+class SyntaxTree::Ident < ::SyntaxTree::Node
+ # @return [Ident] a new instance of Ident
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6188
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6223
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6194
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6198
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6186
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6202
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6198
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6215
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6219
+ def format(q); end
+
+ # [String] the value of the identifier
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6183
+ def value; end
+end
+
+# If represents the first clause in an +if+ chain.
+#
+# if predicate
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6471
+class SyntaxTree::IfNode < ::SyntaxTree::Node
+ # @return [IfNode] a new instance of IfNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6484
+ def initialize(predicate:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6529
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6492
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6496
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6482
+ def comments; end
+
+ # [nil | Elsif | Else] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6479
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6500
+ def copy(predicate: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6496
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6515
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6525
+ def format(q); end
+
+ # Checks if the node was originally found in the modifier form.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6535
+ def modifier?; end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6473
+ def predicate; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6476
+ def statements; end
+end
+
+# IfOp represents a ternary clause.
+#
+# predicate ? truthy : falsy
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6544
+class SyntaxTree::IfOp < ::SyntaxTree::Node
+ # @return [IfOp] a new instance of IfOp
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6557
+ def initialize(predicate:, truthy:, falsy:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6631
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6565
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6569
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6555
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6573
+ def copy(predicate: T.unsafe(nil), truthy: T.unsafe(nil), falsy: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6569
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6588
+ def deconstruct_keys(_keys); end
+
+ # [Node] the expression to be executed if the predicate is falsy
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6552
+ def falsy; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6598
+ def format(q); end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6546
+ def predicate; end
+
+ # [Node] the expression to be executed if the predicate is truthy
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6549
+ def truthy; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6638
+ def format_break(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6661
+ def format_flat(q); end
+end
+
+# Imaginary represents an imaginary number literal.
+#
+# 1i
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6680
+class SyntaxTree::Imaginary < ::SyntaxTree::Node
+ # @return [Imaginary] a new instance of Imaginary
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6687
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6722
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6693
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6697
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6685
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6701
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6697
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6714
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6718
+ def format(q); end
+
+ # [String] the value of the imaginary number literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6682
+ def value; end
+end
+
+# In represents using the +in+ keyword within the Ruby 2.7+ pattern matching
+# syntax.
+#
+# case value
+# in pattern
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6734
+class SyntaxTree::In < ::SyntaxTree::Node
+ # @return [In] a new instance of In
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6747
+ def initialize(pattern:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6812
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6755
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6759
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6745
+ def comments; end
+
+ # [nil | In | Else] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6742
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6763
+ def copy(pattern: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6759
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6778
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6788
+ def format(q); end
+
+ # [Node] the pattern to check against
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6736
+ def pattern; end
+
+ # [Statements] the expressions to execute if the pattern matched
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6739
+ def statements; end
+end
+
+# This class can be used to build an index of the structure of Ruby files. We
+# define an index as the list of constants and methods defined within a file.
+#
+# This index strives to be as fast as possible to better support tools like
+# IDEs. Because of that, it has different backends depending on what
+# functionality is available.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#10
+module SyntaxTree::Index
+ class << self
+ # This method accepts source code and then indexes it.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#674
+ def index(source, backend: T.unsafe(nil)); end
+
+ # This method accepts a filepath and then indexes it.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#679
+ def index_file(filepath, backend: T.unsafe(nil)); end
+ end
+end
+
+# This entry represents a method definition that was created using the alias
+# keyword.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#85
+class SyntaxTree::Index::AliasMethodDefinition
+ # @return [AliasMethodDefinition] a new instance of AliasMethodDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#88
+ def initialize(nesting, name, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#86
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#86
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#86
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#86
+ def nesting; end
+end
+
+# This entry represents a class definition using the class keyword.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#22
+class SyntaxTree::Index::ClassDefinition
+ # @return [ClassDefinition] a new instance of ClassDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#25
+ def initialize(nesting, name, superclass, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#23
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#23
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#23
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#23
+ def nesting; end
+
+ # Returns the value of attribute superclass.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#23
+ def superclass; end
+end
+
+# This entry represents a constant assignment.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#35
+class SyntaxTree::Index::ConstantDefinition
+ # @return [ConstantDefinition] a new instance of ConstantDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#38
+ def initialize(nesting, name, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#36
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#36
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#36
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#36
+ def nesting; end
+end
+
+# This class handles parsing comments from Ruby source code in the case that
+# we use the instruction sequence backend. Because the instruction sequence
+# backend doesn't provide comments (since they are dropped) we provide this
+# interface to lazily parse them out.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#152
+class SyntaxTree::Index::EntryComments
+ include ::Enumerable
+
+ # @return [EntryComments] a new instance of EntryComments
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#156
+ def initialize(file_comments, location); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#161
+ def each(&block); end
+
+ # Returns the value of attribute file_comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#154
+ def file_comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#154
+ def location; end
+end
+
+# When you're using the instruction sequence backend, this class is used to
+# lazily parse comments out of the source code.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#98
+class SyntaxTree::Index::FileComments
+ # @return [FileComments] a new instance of FileComments
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#139
+ def initialize(source); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#143
+ def comments; end
+
+ # Returns the value of attribute source.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#137
+ def source; end
+end
+
+# This represents the Ruby source in the form of a file. When it needs to
+# be read we'll read the file.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#115
+class SyntaxTree::Index::FileComments::FileSource
+ # @return [FileSource] a new instance of FileSource
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#118
+ def initialize(filepath); end
+
+ # Returns the value of attribute filepath.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#116
+ def filepath; end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#122
+ def source; end
+end
+
+# We use the ripper library to pull out source comments.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#100
+class SyntaxTree::Index::FileComments::Parser < ::Ripper
+ # @return [Parser] a new instance of Parser
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#103
+ def initialize(*_arg0); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#101
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#108
+ def on_comment(value); end
+end
+
+# This represents the Ruby source in the form of a string. When it needs
+# to be read the string is returned.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#129
+class SyntaxTree::Index::FileComments::StringSource
+ # @return [StringSource] a new instance of StringSource
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#132
+ def initialize(source); end
+
+ # Returns the value of attribute source.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#130
+ def source; end
+end
+
+# The class defined here is used to perform the indexing, depending on what
+# functionality is available from the runtime.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#670
+SyntaxTree::Index::INDEX_BACKEND = SyntaxTree::Index::ISeqBackend
+
+# This backend creates the index using RubyVM::InstructionSequence, which is
+# faster than using the Syntax Tree parser, but is not available on all
+# runtimes.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#177
+class SyntaxTree::Index::ISeqBackend
+ # source://syntax_tree//lib/syntax_tree/index.rb#184
+ def index(source); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#191
+ def index_file(filepath); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#242
+ def find_attr_arguments(insns, index); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#205
+ def find_constant_path(insns, index); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#273
+ def index_iseq(iseq, file_comments); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#200
+ def location_for(iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#258
+ def method_definition(nesting, name, location, file_comments); end
+end
+
+# source://syntax_tree//lib/syntax_tree/index.rb#182
+SyntaxTree::Index::ISeqBackend::VM_DEFINECLASS_FLAG_HAS_SUPERCLASS = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/index.rb#181
+SyntaxTree::Index::ISeqBackend::VM_DEFINECLASS_FLAG_SCOPED = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/index.rb#178
+SyntaxTree::Index::ISeqBackend::VM_DEFINECLASS_TYPE_CLASS = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/index.rb#180
+SyntaxTree::Index::ISeqBackend::VM_DEFINECLASS_TYPE_MODULE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/index.rb#179
+SyntaxTree::Index::ISeqBackend::VM_DEFINECLASS_TYPE_SINGLETON_CLASS = T.let(T.unsafe(nil), Integer)
+
+# This is a location for an index entry.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#12
+class SyntaxTree::Index::Location
+ # @return [Location] a new instance of Location
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#15
+ def initialize(line, column); end
+
+ # Returns the value of attribute column.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#13
+ def column; end
+
+ # Returns the value of attribute line.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#13
+ def line; end
+end
+
+# This entry represents a method definition using the def keyword.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#59
+class SyntaxTree::Index::MethodDefinition
+ # @return [MethodDefinition] a new instance of MethodDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#62
+ def initialize(nesting, name, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#60
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#60
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#60
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#60
+ def nesting; end
+end
+
+# This entry represents a module definition using the module keyword.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#47
+class SyntaxTree::Index::ModuleDefinition
+ # @return [ModuleDefinition] a new instance of ModuleDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#50
+ def initialize(nesting, name, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#48
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#48
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#48
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#48
+ def nesting; end
+end
+
+# This backend creates the index using the Syntax Tree parser and a visitor.
+# It is not as fast as using the instruction sequences directly, but is
+# supported on all runtimes.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#452
+class SyntaxTree::Index::ParserBackend
+ # source://syntax_tree//lib/syntax_tree/index.rb#659
+ def index(source); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#663
+ def index_file(filepath); end
+end
+
+# source://syntax_tree//lib/syntax_tree/index.rb#453
+class SyntaxTree::Index::ParserBackend::ConstantNameVisitor < ::SyntaxTree::Visitor
+ # source://syntax_tree//lib/syntax_tree/index.rb#458
+ def visit_const_path_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#454
+ def visit_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#462
+ def visit_var_ref(node); end
+end
+
+# source://syntax_tree//lib/syntax_tree/index.rb#467
+class SyntaxTree::Index::ParserBackend::IndexVisitor < ::SyntaxTree::Visitor
+ # @return [IndexVisitor] a new instance of IndexVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#470
+ def initialize; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#468
+ def nesting; end
+
+ # Returns the value of attribute results.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#468
+ def results; end
+
+ # Returns the value of attribute statements.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#468
+ def statements; end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#477
+ def visit_alias(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#496
+ def visit_assign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#515
+ def visit_class(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#547
+ def visit_command(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#584
+ def visit_def(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#608
+ def visit_module(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#626
+ def visit_program(node); end
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#631
+ def visit_statements(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/index.rb#639
+ def comments_for(node); end
+end
+
+# This entry represents a singleton method definition using the def keyword
+# with a specified target.
+#
+# source://syntax_tree//lib/syntax_tree/index.rb#72
+class SyntaxTree::Index::SingletonMethodDefinition
+ # @return [SingletonMethodDefinition] a new instance of SingletonMethodDefinition
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#75
+ def initialize(nesting, name, location, comments); end
+
+ # Returns the value of attribute comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#73
+ def comments; end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#73
+ def location; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#73
+ def name; end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/index.rb#73
+ def nesting; end
+end
+
+# Int represents an integer number literal.
+#
+# 1
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6822
+class SyntaxTree::Int < ::SyntaxTree::Node
+ # @return [Int] a new instance of Int
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6829
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6869
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6835
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6839
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6827
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6843
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6839
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6853
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6857
+ def format(q); end
+
+ # [String] the value of the integer
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6824
+ def value; end
+end
+
+# This visitor transforms the AST into a hash that contains only primitives
+# that can be easily serialized into JSON.
+#
+# source://syntax_tree//lib/syntax_tree/json_visitor.rb#8
+class SyntaxTree::JSONVisitor < ::SyntaxTree::FieldVisitor
+ # @return [JSONVisitor] a new instance of JSONVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#11
+ def initialize; end
+
+ # Returns the value of attribute target.
+ #
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#9
+ def target; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#17
+ def comments(node); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#21
+ def field(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#25
+ def list(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#29
+ def node(node, type); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#38
+ def pairs(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#42
+ def text(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/json_visitor.rb#46
+ def visit_location(location); end
+end
+
+# Kw represents the use of a keyword. It can be almost anywhere in the syntax
+# tree, so you end up seeing it quite a lot.
+#
+# if value
+# end
+#
+# In the above example, there would be two Kw nodes: one for the if and one
+# for the end. Note that anything that matches the list of keywords in Ruby
+# will use a Kw, so if you use a keyword in a symbol literal for instance:
+#
+# :if
+#
+# then the contents of the symbol node will contain a Kw node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6938
+class SyntaxTree::Kw < ::SyntaxTree::Node
+ # @return [Kw] a new instance of Kw
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6948
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6981
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6955
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6959
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6946
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6963
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6959
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6973
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#6977
+ def format(q); end
+
+ # [Symbol] the symbol version of the value
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6943
+ def name; end
+
+ # [String] the value of the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6940
+ def value; end
+end
+
+# KwRestParam represents defining a parameter in a method definition that
+# accepts all remaining keyword parameters.
+#
+# def method(**kwargs) end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6991
+class SyntaxTree::KwRestParam < ::SyntaxTree::Node
+ # @return [KwRestParam] a new instance of KwRestParam
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6998
+ def initialize(name:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7034
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7004
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7008
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6996
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7012
+ def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7008
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7025
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7029
+ def format(q); end
+
+ # [nil | Ident] the name of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6993
+ def name; end
+end
+
+# LBrace represents the use of a left brace, i.e., {.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7316
+class SyntaxTree::LBrace < ::SyntaxTree::Node
+ # @return [LBrace] a new instance of LBrace
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7323
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7358
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7329
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7333
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7321
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7337
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7333
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7350
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7354
+ def format(q); end
+
+ # [String] the left brace
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7318
+ def value; end
+
+ class << self
+ # Because some nodes keep around a { token so that comments can be attached
+ # to it if they occur in the source, oftentimes an LBrace is a child of
+ # another node. This means it's required at initialization time. To make it
+ # easier to create LBrace nodes without any specific value, this method
+ # provides a default node.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7367
+ def default; end
+ end
+end
+
+# LBracket represents the use of a left bracket, i.e., [.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7373
+class SyntaxTree::LBracket < ::SyntaxTree::Node
+ # @return [LBracket] a new instance of LBracket
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7380
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7415
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7386
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7390
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7378
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7394
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7390
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7407
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7411
+ def format(q); end
+
+ # [String] the left bracket
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7375
+ def value; end
+
+ class << self
+ # Because some nodes keep around a [ token so that comments can be attached
+ # to it if they occur in the source, oftentimes an LBracket is a child of
+ # another node. This means it's required at initialization time. To make it
+ # easier to create LBracket nodes without any specific value, this method
+ # provides a default node.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7424
+ def default; end
+ end
+end
+
+# LParen represents the use of a left parenthesis, i.e., (.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7430
+class SyntaxTree::LParen < ::SyntaxTree::Node
+ # @return [LParen] a new instance of LParen
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7437
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7472
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7443
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7447
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7435
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7451
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7447
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7464
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7468
+ def format(q); end
+
+ # [String] the left parenthesis
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7432
+ def value; end
+
+ class << self
+ # Because some nodes keep around a ( token so that comments can be attached
+ # to it if they occur in the source, oftentimes an LParen is a child of
+ # another node. This means it's required at initialization time. To make it
+ # easier to create LParen nodes without any specific value, this method
+ # provides a default node.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7481
+ def default; end
+ end
+end
+
+# Label represents the use of an identifier to associate with an object. You
+# can find it in a hash key, as in:
+#
+# { key: value }
+#
+# In this case "key:" would be the body of the label. You can also find it in
+# pattern matching, as in:
+#
+# case value
+# in key:
+# end
+#
+# In this case "key:" would be the body of the label.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7052
+class SyntaxTree::Label < ::SyntaxTree::Node
+ # @return [Label] a new instance of Label
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7059
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7094
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7065
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7069
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7057
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7073
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7069
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7086
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7090
+ def format(q); end
+
+ # [String] the value of the label
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7054
+ def value; end
+end
+
+# LabelEnd represents the end of a dynamic symbol.
+#
+# { "key": value }
+#
+# In the example above, LabelEnd represents the "\":" token at the end of the
+# hash key. This node is important for determining the type of quote being
+# used by the label.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7106
+class SyntaxTree::LabelEnd < ::SyntaxTree::Node
+ # @return [LabelEnd] a new instance of LabelEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7110
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7136
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7115
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7119
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7123
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7119
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7132
+ def deconstruct_keys(_keys); end
+
+ # [String] the end of the label
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7108
+ def value; end
+end
+
+# Lambda represents using a lambda literal (not the lambda method call).
+#
+# ->(value) { value * 2 }
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7145
+class SyntaxTree::Lambda < ::SyntaxTree::Node
+ # @return [Lambda] a new instance of Lambda
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7155
+ def initialize(params:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7239
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7162
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7166
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7153
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7170
+ def copy(params: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7166
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7184
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7193
+ def format(q); end
+
+ # [LambdaVar | Paren] the parameter declaration for this lambda
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7147
+ def params; end
+
+ # [BodyStmt | Statements] the expressions to be executed in this lambda
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7150
+ def statements; end
+end
+
+# LambdaVar represents the parameters being declared for a lambda. Effectively
+# this node is everything contained within the parentheses. This includes all
+# of the various parameter types, as well as block-local variable
+# declarations.
+#
+# -> (positional, optional = value, keyword:, █ local) do
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7253
+class SyntaxTree::LambdaVar < ::SyntaxTree::Node
+ # @return [LambdaVar] a new instance of LambdaVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7263
+ def initialize(params:, locals:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7309
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7270
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7274
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7261
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7278
+ def copy(params: T.unsafe(nil), locals: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7274
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7292
+ def deconstruct_keys(_keys); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7296
+ def empty?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7300
+ def format(q); end
+
+ # [Array[ Ident ]] the list of block-local variable declarations
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7258
+ def locals; end
+
+ # [Params] the parameters being declared with the block
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7255
+ def params; end
+end
+
+# Syntax Tree additionally ships with a language server conforming to the
+# language server protocol. It can be invoked through the CLI by running:
+#
+# stree lsp
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#14
+class SyntaxTree::LanguageServer
+ # @return [LanguageServer] a new instance of LanguageServer
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#217
+ def initialize(input: T.unsafe(nil), output: T.unsafe(nil), print_width: T.unsafe(nil)); end
+
+ # Returns the value of attribute input.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#215
+ def input; end
+
+ # Returns the value of attribute output.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#215
+ def output; end
+
+ # Returns the value of attribute print_width.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#215
+ def print_width; end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#228
+ def run; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#280
+ def capabilities; end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#293
+ def format(source, extension); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#317
+ def inlay_hints(source); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#333
+ def log(message); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#327
+ def write(value); end
+end
+
+# This class provides inlay hints for the language server. For more
+# information, see the spec here:
+# https://github.com/microsoft/language-server-protocol/issues/956.
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#18
+class SyntaxTree::LanguageServer::InlayHints < ::SyntaxTree::Visitor
+ # @return [InlayHints] a new instance of InlayHints
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#43
+ def initialize; end
+
+ # Returns the value of attribute hints.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#41
+ def hints; end
+
+ # Returns the value of attribute stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#41
+ def stack; end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#48
+ def visit(node); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#67
+ def visit_assign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#81
+ def visit_binary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#102
+ def visit_if_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#124
+ def visit_rescue(node); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#145
+ def visit_unary(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#156
+ def parentheses(location); end
+end
+
+# This represents a hint that is going to be displayed in the editor.
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#20
+class SyntaxTree::LanguageServer::InlayHints::Hint
+ # @return [Hint] a new instance of Hint
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#23
+ def initialize(line:, character:, label:); end
+
+ # Returns the value of attribute character.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#21
+ def character; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#21
+ def label; end
+
+ # Returns the value of attribute line.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#21
+ def line; end
+
+ # This is the shape that the LSP expects.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#30
+ def to_json(*opts); end
+end
+
+# This is a small module that effectively mirrors pattern matching. We're
+# using it so that we can support truffleruby without having to ignore the
+# language server.
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#174
+module SyntaxTree::LanguageServer::Request
+ class << self
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#203
+ def [](value); end
+ end
+end
+
+# Represents a hash pattern.
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#176
+class SyntaxTree::LanguageServer::Request::Shape
+ # @return [Shape] a new instance of Shape
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#179
+ def initialize(values); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#183
+ def ===(other); end
+
+ # Returns the value of attribute values.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#177
+ def values; end
+end
+
+# Represents an array pattern.
+#
+# source://syntax_tree//lib/syntax_tree/language_server.rb#191
+class SyntaxTree::LanguageServer::Request::Tuple
+ # @return [Tuple] a new instance of Tuple
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#194
+ def initialize(values); end
+
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#198
+ def ===(other); end
+
+ # Returns the value of attribute values.
+ #
+ # source://syntax_tree//lib/syntax_tree/language_server.rb#192
+ def values; end
+end
+
+# Represents the location of a node in the tree from the source code.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#5
+class SyntaxTree::Location
+ # @return [Location] a new instance of Location
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#13
+ def initialize(start_line:, start_char:, start_column:, end_line:, end_char:, end_column:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#33
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#50
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#54
+ def deconstruct_keys(_keys); end
+
+ # Returns the value of attribute end_char.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def end_char; end
+
+ # Returns the value of attribute end_column.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def end_column; end
+
+ # Returns the value of attribute end_line.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def end_line; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#29
+ def lines; end
+
+ # Returns the value of attribute start_char.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def start_char; end
+
+ # Returns the value of attribute start_column.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def start_column; end
+
+ # Returns the value of attribute start_line.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6
+ def start_line; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#39
+ def to(other); end
+
+ class << self
+ # A convenience method that is typically used when you don't care about the
+ # location of a node, but need to create a Location instance to pass to a
+ # constructor.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#90
+ def default; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#76
+ def fixed(line:, char:, column:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#65
+ def token(line:, char:, column:, size:); end
+ end
+end
+
+# Formats an Until or While node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11378
+class SyntaxTree::LoopFormatter
+ # @return [LoopFormatter] a new instance of LoopFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11385
+ def initialize(keyword, node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11390
+ def format(q); end
+
+ # [String] the name of the keyword used for this loop
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11380
+ def keyword; end
+
+ # [Until | While] the node that is being formatted
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11383
+ def node; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11437
+ def format_break(q); end
+end
+
+# MAssign is a parent node of any kind of multiple assignment. This includes
+# splitting out variables on the left like:
+#
+# first, second, third = value
+#
+# as well as splitting out variables on the right, as in:
+#
+# value = first, second, third
+#
+# Both sides support splats, as well as variables following them. There's also
+# destructuring behavior that you can achieve with the following:
+#
+# first, = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7500
+class SyntaxTree::MAssign < ::SyntaxTree::Node
+ # @return [MAssign] a new instance of MAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7510
+ def initialize(target:, value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7554
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7517
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7521
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7508
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7525
+ def copy(target: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7521
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7539
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7543
+ def format(q); end
+
+ # [MLHS | MLHSParen] the target of the multiple assignment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7502
+ def target; end
+
+ # [Node] the value being assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7505
+ def value; end
+end
+
+# MLHS represents a list of values being destructured on the left-hand side
+# of a multiple assignment.
+#
+# first, second, third = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7638
+class SyntaxTree::MLHS < ::SyntaxTree::Node
+ # @return [MLHS] a new instance of MLHS
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7655
+ def initialize(parts:, location:, comma: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7693
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7662
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7666
+ def child_nodes; end
+
+ # [boolean] whether or not there is a trailing comma at the end of this
+ # list, which impacts destructuring. It's an attr_accessor so that while
+ # the syntax tree is being built it can be set by its parent node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7650
+ def comma; end
+
+ # [boolean] whether or not there is a trailing comma at the end of this
+ # list, which impacts destructuring. It's an attr_accessor so that while
+ # the syntax tree is being built it can be set by its parent node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7650
+ def comma=(_arg0); end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7653
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7670
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil), comma: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7666
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7684
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7688
+ def format(q); end
+
+ # [
+ # Array[
+ # ARefField | ArgStar | ConstPathField | Field | Ident | MLHSParen |
+ # TopConstField | VarField
+ # ]
+ # ] the parts of the left-hand side of a multiple assignment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7645
+ def parts; end
+end
+
+# MLHSParen represents parentheses being used to destruct values in a multiple
+# assignment on the left hand side.
+#
+# (left, right) = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7704
+class SyntaxTree::MLHSParen < ::SyntaxTree::Node
+ # @return [MLHSParen] a new instance of MLHSParen
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7716
+ def initialize(contents:, location:, comma: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7769
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7723
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7727
+ def child_nodes; end
+
+ # [boolean] whether or not there is a trailing comma at the end of this
+ # list, which impacts destructuring. It's an attr_accessor so that while
+ # the syntax tree is being built it can be set by its parent node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7711
+ def comma; end
+
+ # [boolean] whether or not there is a trailing comma at the end of this
+ # list, which impacts destructuring. It's an attr_accessor so that while
+ # the syntax tree is being built it can be set by its parent node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7711
+ def comma=(_arg0); end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7714
+ def comments; end
+
+ # [MLHS | MLHSParen] the contents inside of the parentheses
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7706
+ def contents; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7731
+ def copy(contents: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7727
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7744
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7748
+ def format(q); end
+end
+
+# MRHS represents the values that are being assigned on the right-hand side of
+# a multiple assignment.
+#
+# values = first, second, third
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7869
+class SyntaxTree::MRHS < ::SyntaxTree::Node
+ # @return [MRHS] a new instance of MRHS
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7876
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7911
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7882
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7886
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7874
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7890
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7886
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7903
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7907
+ def format(q); end
+
+ # [Array[Node]] the parts that are being assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7871
+ def parts; end
+end
+
+# This visitor transforms the AST into a Ruby pattern matching expression that
+# would match correctly against the AST.
+#
+# source://syntax_tree//lib/syntax_tree/match_visitor.rb#6
+class SyntaxTree::MatchVisitor < ::SyntaxTree::FieldVisitor
+ # @return [MatchVisitor] a new instance of MatchVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#9
+ def initialize(q); end
+
+ # Returns the value of attribute q.
+ #
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#7
+ def q; end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#13
+ def visit(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#30
+ def comments(node); end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#44
+ def field(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#52
+ def list(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#65
+ def node(node, _type); end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#86
+ def pairs(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/match_visitor.rb#112
+ def text(name, value); end
+end
+
+# This module is responsible for rendering mermaid (https://mermaid.js.org/)
+# flow charts.
+#
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#9
+module SyntaxTree::Mermaid
+ class << self
+ # Escape a label to be used in the mermaid syntax. This is used to escape
+ # HTML entities such that they render properly within the quotes.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#158
+ def escape(label); end
+
+ # Create a new flowchart. If a block is given, it will be yielded to and
+ # the flowchart will be rendered. Otherwise, the flowchart will be
+ # returned.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#165
+ def flowchart; end
+ end
+end
+
+# This is the main class that handles rendering a flowchart. It keeps track
+# of its nodes and links and renders them according to the mermaid syntax.
+#
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#12
+class SyntaxTree::Mermaid::FlowChart
+ # @return [FlowChart] a new instance of FlowChart
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#15
+ def initialize; end
+
+ # Retrieve a node that has already been added to the flowchart by its id.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#25
+ def fetch(id); end
+
+ # Add a link to the flowchart between two nodes with an optional label.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#30
+ def link(from, to, label = T.unsafe(nil), type: T.unsafe(nil), color: T.unsafe(nil)); end
+
+ # Returns the value of attribute links.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#13
+ def links; end
+
+ # Add a node to the flowchart with an optional label.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#39
+ def node(id, label = T.unsafe(nil), shape: T.unsafe(nil)); end
+
+ # Returns the value of attribute nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#13
+ def nodes; end
+
+ # Returns the value of attribute output.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#13
+ def output; end
+
+ # Returns the value of attribute prefix.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#13
+ def prefix; end
+
+ # Return the rendered flowchart.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#64
+ def render; end
+
+ # Add a subgraph to the flowchart. Within the given block, all of the
+ # nodes will be rendered within the subgraph.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#49
+ def subgraph(label); end
+end
+
+# This class represents a link between two nodes in a flowchart. It is not
+# meant to be interacted with directly, but rather used as a data structure
+# by the FlowChart class.
+#
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#78
+class SyntaxTree::Mermaid::Link
+ # @return [Link] a new instance of Link
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#84
+ def initialize(from, to, label, type, color); end
+
+ # Returns the value of attribute color.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#82
+ def color; end
+
+ # Returns the value of attribute from.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#82
+ def from; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#82
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#95
+ def render; end
+
+ # Returns the value of attribute to.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#82
+ def to; end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#82
+ def type; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#108
+ def sides; end
+end
+
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#80
+SyntaxTree::Mermaid::Link::COLORS = T.let(T.unsafe(nil), Array)
+
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#79
+SyntaxTree::Mermaid::Link::TYPES = T.let(T.unsafe(nil), Array)
+
+# This class represents a node in a flowchart. Unlike the Link class, it can
+# be used directly. It is the return value of the #node method, and is meant
+# to be passed around to #link methods to create links between nodes.
+#
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#121
+class SyntaxTree::Mermaid::Node
+ # @return [Node] a new instance of Node
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#126
+ def initialize(id, label, shape); end
+
+ # Returns the value of attribute id.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#124
+ def id; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#124
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#134
+ def render; end
+
+ # Returns the value of attribute shape.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#124
+ def shape; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/mermaid.rb#141
+ def bounds; end
+end
+
+# source://syntax_tree//lib/syntax_tree/mermaid.rb#122
+SyntaxTree::Mermaid::Node::SHAPES = T.let(T.unsafe(nil), Array)
+
+# This visitor transforms the AST into a mermaid flow chart.
+#
+# source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#5
+class SyntaxTree::MermaidVisitor < ::SyntaxTree::FieldVisitor
+ # @return [MermaidVisitor] a new instance of MermaidVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#8
+ def initialize; end
+
+ # Returns the value of attribute flowchart.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#6
+ def flowchart; end
+
+ # Returns the value of attribute target.
+ #
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#6
+ def target; end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#13
+ def visit_program(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#20
+ def comments(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#24
+ def field(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#37
+ def list(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#43
+ def node(node, type); end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#55
+ def pairs(name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/mermaid_visitor.rb#65
+ def text(name, value); end
+end
+
+# MethodAddBlock represents a method call with a block argument.
+#
+# method {}
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7563
+class SyntaxTree::MethodAddBlock < ::SyntaxTree::Node
+ # @return [MethodAddBlock] a new instance of MethodAddBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7573
+ def initialize(call:, block:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7622
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7580
+ def accept(visitor); end
+
+ # [BlockNode] the block being sent with the method call
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7568
+ def block; end
+
+ # [ARef | CallNode | Command | CommandCall | Super | ZSuper] the method call
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7565
+ def call; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7584
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7571
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7588
+ def copy(call: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7584
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7602
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7606
+ def format(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7627
+ def format_contents(q); end
+end
+
+# ModuleDeclaration represents defining a module using the +module+ keyword.
+#
+# module Namespace
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7779
+class SyntaxTree::ModuleDeclaration < ::SyntaxTree::Node
+ # @return [ModuleDeclaration] a new instance of ModuleDeclaration
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7789
+ def initialize(constant:, bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7849
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7796
+ def accept(visitor); end
+
+ # [BodyStmt] the expressions to be executed in the context of the module
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7784
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7800
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7787
+ def comments; end
+
+ # [ConstPathRef | ConstRef | TopConstRef] the name of the module
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7781
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7804
+ def copy(constant: T.unsafe(nil), bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7800
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7818
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7827
+ def format(q); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7856
+ def format_declaration(q); end
+end
+
+# This visitor walks through the tree and copies each node as it is being
+# visited. This is useful for mutating the tree before it is formatted.
+#
+# source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#6
+class SyntaxTree::MutationVisitor < ::SyntaxTree::BasicVisitor
+ # @return [MutationVisitor] a new instance of MutationVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#9
+ def initialize; end
+
+ # Create a new mutation based on the given query that will mutate the node
+ # using the given block. The block should return a new node that will take
+ # the place of the given node in the tree. These blocks frequently make use
+ # of the `copy` method on nodes to create a new node with the same
+ # properties as the original node.
+ #
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#18
+ def mutate(query, &block); end
+
+ # Returns the value of attribute mutations.
+ #
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#7
+ def mutations; end
+
+ # This is the base visit method for each node in the tree. It first creates
+ # a copy of the node using the visit_* methods defined below. Then it checks
+ # each mutation in sequence and calls it if it finds a match.
+ #
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#25
+ def visit(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#38
+ def visit_BEGIN(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#46
+ def visit_CHAR(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#51
+ def visit_END(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#59
+ def visit___end__(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#64
+ def visit_alias(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#69
+ def visit_aref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#74
+ def visit_aref_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#89
+ def visit_arg_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#79
+ def visit_arg_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#94
+ def visit_arg_star(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#84
+ def visit_args(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#99
+ def visit_args_forward(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#104
+ def visit_array(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#112
+ def visit_aryptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#122
+ def visit_assign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#127
+ def visit_assoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#132
+ def visit_assoc_splat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#137
+ def visit_backref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#142
+ def visit_backtick(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#147
+ def visit_bare_assoc_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#152
+ def visit_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#162
+ def visit_binary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#295
+ def visit_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#167
+ def visit_block_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#172
+ def visit_blockarg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#177
+ def visit_bodystmt(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#187
+ def visit_break(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#192
+ def visit_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#202
+ def visit_case(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#216
+ def visit_class(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#225
+ def visit_comma(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#230
+ def visit_command(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#239
+ def visit_command_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#249
+ def visit_comment(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#254
+ def visit_const(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#259
+ def visit_const_path_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#264
+ def visit_const_path_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#269
+ def visit_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#274
+ def visit_cvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#279
+ def visit_def(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#290
+ def visit_defined(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#313
+ def visit_dyna_symbol(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#318
+ def visit_else(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#326
+ def visit_elsif(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#334
+ def visit_embdoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#339
+ def visit_embexpr_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#344
+ def visit_embexpr_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#349
+ def visit_embvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#354
+ def visit_ensure(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#362
+ def visit_excessed_comma(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#367
+ def visit_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#375
+ def visit_float(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#380
+ def visit_fndptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#390
+ def visit_for(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#395
+ def visit_gvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#400
+ def visit_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#405
+ def visit_heredoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#414
+ def visit_heredoc_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#419
+ def visit_heredoc_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#424
+ def visit_hshptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#434
+ def visit_ident(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#439
+ def visit_if(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#448
+ def visit_if_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#453
+ def visit_imaginary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#458
+ def visit_in(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#466
+ def visit_int(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#471
+ def visit_ivar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#476
+ def visit_kw(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#481
+ def visit_kwrest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#486
+ def visit_label(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#491
+ def visit_label_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#496
+ def visit_lambda(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#504
+ def visit_lambda_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#509
+ def visit_lbrace(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#514
+ def visit_lbracket(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#519
+ def visit_lparen(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#524
+ def visit_massign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#529
+ def visit_method_add_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#534
+ def visit_mlhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#539
+ def visit_mlhs_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#544
+ def visit_module(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#552
+ def visit_mrhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#557
+ def visit_next(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#812
+ def visit_not(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#562
+ def visit_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#567
+ def visit_opassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#572
+ def visit_params(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#588
+ def visit_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#593
+ def visit_period(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#157
+ def visit_pinned_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#854
+ def visit_pinned_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#598
+ def visit_program(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#603
+ def visit_qsymbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#611
+ def visit_qsymbols_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#616
+ def visit_qwords(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#624
+ def visit_qwords_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#304
+ def visit_range(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#211
+ def visit_rassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#629
+ def visit_rational(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#634
+ def visit_rbrace(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#639
+ def visit_rbracket(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#644
+ def visit_redo(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#654
+ def visit_regexp_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#649
+ def visit_regexp_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#659
+ def visit_regexp_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#664
+ def visit_regexp_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#674
+ def visit_rescue(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#669
+ def visit_rescue_ex(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#684
+ def visit_rescue_mod(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#689
+ def visit_rest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#694
+ def visit_retry(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#699
+ def visit_return(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#704
+ def visit_rparen(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#709
+ def visit_sclass(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#714
+ def visit_statements(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#724
+ def visit_string_concat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#719
+ def visit_string_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#729
+ def visit_string_dvar(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#734
+ def visit_string_embexpr(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#739
+ def visit_string_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#744
+ def visit_super(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#749
+ def visit_symbeg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#754
+ def visit_symbol_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#759
+ def visit_symbol_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#764
+ def visit_symbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#772
+ def visit_symbols_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#777
+ def visit_tlambda(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#782
+ def visit_tlambeg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#787
+ def visit_top_const_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#792
+ def visit_top_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#797
+ def visit_tstring_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#802
+ def visit_tstring_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#807
+ def visit_tstring_end(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#817
+ def visit_unary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#822
+ def visit_undef(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#827
+ def visit_unless(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#836
+ def visit_until(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#844
+ def visit_var_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#849
+ def visit_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#859
+ def visit_vcall(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#864
+ def visit_void_stmt(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#869
+ def visit_when(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#878
+ def visit_while(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#886
+ def visit_word(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#891
+ def visit_words(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#899
+ def visit_words_beg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#904
+ def visit_xstring(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#909
+ def visit_xstring_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#914
+ def visit_yield(node); end
+
+ # source://syntax_tree//lib/syntax_tree/mutation_visitor.rb#919
+ def visit_zsuper(node); end
+end
+
+# Next represents using the +next+ keyword.
+#
+# next
+#
+# The +next+ keyword can also optionally be called with an argument:
+#
+# next value
+#
+# +next+ can even be called with multiple arguments, but only if parentheses
+# are omitted, as in:
+#
+# next first, second, third
+#
+# If a single value is being given, parentheses can be used, as in:
+#
+# next(value)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7933
+class SyntaxTree::Next < ::SyntaxTree::Node
+ # @return [Next] a new instance of Next
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7940
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7975
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7946
+ def accept(visitor); end
+
+ # [Args] the arguments passed to the next keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7935
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7950
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7938
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7954
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7950
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7967
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#7971
+ def format(q); end
+end
+
+# This is the parent node of all of the syntax tree nodes. It's pretty much
+# exclusively here to make it easier to operate with the tree in cases where
+# you're trying to monkey-patch or strictly type.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#105
+class SyntaxTree::Node
+ # @raise [NotImplementedError]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#109
+ def accept(visitor); end
+
+ # @raise [NotImplementedError]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#113
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#149
+ def construct_keys; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#117
+ def deconstruct; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#121
+ def deconstruct_keys(keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#133
+ def end_char; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#125
+ def format(q); end
+
+ # [Location] the location of this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#107
+ def location; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#137
+ def pretty_print(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#129
+ def start_char; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#141
+ def to_json(*opts); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#145
+ def to_mermaid; end
+end
+
+# Not represents the unary +not+ method being called on an expression.
+#
+# not value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11077
+class SyntaxTree::Not < ::SyntaxTree::Node
+ # @return [Not] a new instance of Not
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11088
+ def initialize(statement:, parentheses:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11150
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11095
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11099
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11086
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11103
+ def copy(statement: T.unsafe(nil), parentheses: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11099
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11117
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11126
+ def format(q); end
+
+ # [boolean] whether or not parentheses were used
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11082
+ def parentheses; end
+
+ # [boolean] whether or not parentheses were used
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11082
+ def parentheses?; end
+
+ # [nil | Node] the statement on which to operate
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11079
+ def statement; end
+end
+
+# Op represents an operator literal in the source.
+#
+# 1 + 2
+#
+# In the example above, the Op node represents the + operator.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#7985
+class SyntaxTree::Op < ::SyntaxTree::Node
+ # @return [Op] a new instance of Op
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7995
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8028
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8002
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8006
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7993
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8010
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8006
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8020
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8024
+ def format(q); end
+
+ # [Symbol] the symbol version of the value
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7990
+ def name; end
+
+ # [String] the operator
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#7987
+ def value; end
+end
+
+# OpAssign represents assigning a value to a variable or constant using an
+# operator like += or ||=.
+#
+# variable += value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8038
+class SyntaxTree::OpAssign < ::SyntaxTree::Node
+ # @return [OpAssign] a new instance of OpAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8052
+ def initialize(target:, operator:, value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8111
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8060
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8064
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8050
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8068
+ def copy(target: T.unsafe(nil), operator: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8064
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8083
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8093
+ def format(q); end
+
+ # [Op] the operator being used for the assignment
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8044
+ def operator; end
+
+ # [ARefField | ConstPathField | Field | TopConstField | VarField] the target
+ # to assign the result of the expression to
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8041
+ def target; end
+
+ # [Node] the expression to be assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8047
+ def value; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8118
+ def skip_indent?; end
+end
+
+# The list of nodes that represent patterns inside of pattern matching so that
+# when a pattern is being printed it knows if it's nested.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6174
+SyntaxTree::PATTERNS = T.let(T.unsafe(nil), Array)
+
+# Params represents defining parameters on a method or lambda.
+#
+# def method(param) end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8196
+class SyntaxTree::Params < ::SyntaxTree::Node
+ # @return [Params] a new instance of Params
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8298
+ def initialize(location:, 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
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8428
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8328
+ def accept(visitor); end
+
+ # Returns a range representing the possible number of arguments accepted
+ # by this params node not including the block. For example:
+ #
+ # def foo(a, b = 1, c:, d: 2, &block)
+ # ...
+ # end
+ #
+ # has arity 2..4.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8451
+ def arity; end
+
+ # [nil | BlockArg] the optional block parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8293
+ def block; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8332
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8296
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8346
+ def copy(location: 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
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8332
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8374
+ def deconstruct_keys(_keys); end
+
+ # Params nodes are the most complicated in the tree. Occasionally you want
+ # to know if they are "empty", which means not having any parameters
+ # declared. This logic accesses every kind of parameter and determines if
+ # it's missing.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8323
+ def empty?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8388
+ def format(q); end
+
+ # [nil | :nil | ArgsForward | KwRestParam] the optional keyword rest
+ # parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8290
+ def keyword_rest; end
+
+ # [Array[ [ Label, nil | Node ] ]] any keyword parameters and their
+ # optional default values
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8286
+ def keywords; end
+
+ # [Array[ [ Ident, Node ] ]] any optional parameters and their default
+ # values
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8274
+ def optionals; end
+
+ # [Array[ Ident | MLHSParen ]] any positional parameters that exist after a
+ # rest parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8282
+ def posts; end
+
+ # [Array[ Ident | MLHSParen ]] any required parameters
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8270
+ def requireds; end
+
+ # [nil | ArgsForward | ExcessedComma | RestParam] the optional rest
+ # parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8278
+ def rest; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8467
+ def format_contents(q, parts); end
+end
+
+# Formats the keyword position of the parameters. This includes the label,
+# as well as an optional default value.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8224
+class SyntaxTree::Params::KeywordFormatter
+ # @return [KeywordFormatter] a new instance of KeywordFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8231
+ def initialize(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8236
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8240
+ def format(q); end
+
+ # [Ident] the name of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8226
+ def name; end
+
+ # [nil | Node] the value of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8229
+ def value; end
+end
+
+# Formats the keyword_rest position of the parameters. This can be the **nil
+# syntax, the ... syntax, or the ** syntax.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8252
+class SyntaxTree::Params::KeywordRestFormatter
+ # @return [KeywordRestFormatter] a new instance of KeywordRestFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8256
+ def initialize(value); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8260
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8264
+ def format(q); end
+
+ # [:nil | ArgsForward | KwRestParam] the value of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8254
+ def value; end
+end
+
+# Formats the optional position of the parameters. This includes the label,
+# as well as the default value.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8199
+class SyntaxTree::Params::OptionalFormatter
+ # @return [OptionalFormatter] a new instance of OptionalFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8206
+ def initialize(name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8211
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8215
+ def format(q); end
+
+ # [Ident] the name of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8201
+ def name; end
+
+ # [Node] the value of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8204
+ def value; end
+end
+
+# Paren represents using balanced parentheses in a couple places in a Ruby
+# program. In general parentheses can be used anywhere a Ruby expression can
+# be used.
+#
+# (1 + 2)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8479
+class SyntaxTree::Paren < ::SyntaxTree::Node
+ # @return [Paren] a new instance of Paren
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8489
+ def initialize(lparen:, contents:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8545
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8496
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8500
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8487
+ def comments; end
+
+ # [nil | Node] the expression inside the parentheses
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8484
+ def contents; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8504
+ def copy(lparen: T.unsafe(nil), contents: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8500
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8518
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8527
+ def format(q); end
+
+ # [LParen] the left parenthesis that opened this statement
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8481
+ def lparen; end
+end
+
+# If you have a modifier statement (for instance a modifier if statement or a
+# modifier while loop) there are times when you need to wrap the entire
+# statement in parentheses. This occurs when you have something like:
+#
+# foo[:foo] =
+# if bar?
+# baz
+# end
+#
+# Normally we would shorten this to an inline version, which would result in:
+#
+# foo[:foo] = baz if bar?
+#
+# but this actually has different semantic meaning. The first example will
+# result in a nil being inserted into the hash for the :foo key, whereas the
+# second example will result in an empty hash because the if statement applies
+# to the entire assignment.
+#
+# We can fix this in a couple of ways. We can use the then keyword, as in:
+#
+# foo[:foo] = if bar? then baz end
+#
+# But this isn't used very often. We can also just leave it as is with the
+# multi-line version, but for a short predicate and short value it looks
+# verbose. The last option and the one used here is to add parentheses on
+# both sides of the expression, as in:
+#
+# foo[:foo] = (baz if bar?)
+#
+# This approach maintains the nice conciseness of the inline version, while
+# keeping the correct semantic meaning.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8155
+module SyntaxTree::Parentheses
+ class << self
+ # source://syntax_tree//lib/syntax_tree/node.rb#8175
+ def break(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8167
+ def flat(q); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/node.rb#8156
+SyntaxTree::Parentheses::NODES = T.let(T.unsafe(nil), Array)
+
+# Parser is a subclass of the Ripper library that subscribes to the stream of
+# tokens and nodes coming from the parser and builds up a syntax tree.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#6
+class SyntaxTree::Parser < ::Ripper
+ # @return [Parser] a new instance of Parser
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#116
+ def initialize(source, *_arg1); end
+
+ # [Array[ Comment | EmbDoc ]] the list of comments that have been found
+ # while parsing the source.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#114
+ def comments; end
+
+ # [Array[ SingleByteString | MultiByteString ]] the list of objects that
+ # represent the start of each line in character offsets
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#105
+ def line_counts; end
+
+ # [String] the source being parsed
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#101
+ def source; end
+
+ # [Array[ untyped ]] a running list of tokens that have been found in the
+ # source. This list changes a lot as certain nodes will "consume" these
+ # tokens to determine their bounds.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#110
+ def tokens; end
+
+ private
+
+ # Attaches comments to the nodes in the tree that most closely correspond to
+ # the location of the comments.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2911
+ def attach_comments(program, comments); end
+
+ # This represents the current place in the source string that we've gotten
+ # to so far. We have a memoized line_counts object that we can use to get
+ # the number of characters that we've had to go through to get to the
+ # beginning of this line, then we add the number of columns into this line
+ # that we've gone through.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#197
+ def char_pos; end
+
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#295
+ def consume_error(name, location); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#312
+ def consume_keyword(name); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#318
+ def consume_operator(name); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#300
+ def consume_token(type); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#306
+ def consume_tstring_end(location); end
+
+ # This represents the current column we're in relative to the beginning of
+ # the current line.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#203
+ def current_column; end
+
+ # A helper function to find a :: operator. We do special handling instead of
+ # using find_token here because we don't pop off all of the :: operators so
+ # you could end up getting the wrong information if you have for instance
+ # ::X::Y::Z.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#328
+ def find_colon2_before(const); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#272
+ def find_keyword(name); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#277
+ def find_keyword_between(name, left, right); end
+
+ # Finds the next position in the source string that begins a statement. This
+ # is used to bind statements lists and make sure they don't include a
+ # preceding comment. For example, we want the following comment to be
+ # attached to the class node and not the statement node:
+ #
+ # ...
+ # end
+ #
+ # By finding the next non-space character, we can make sure that the bounds
+ # of the statement list are correct.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#349
+ def find_next_statement_start(position); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#290
+ def find_operator(name); end
+
+ # As we build up a list of tokens, we'll periodically need to go backwards
+ # and find the ones that we've already hit in order to determine the
+ # location information for nodes that use them. For example, if you have a
+ # module node then you'll look backward for a kw token to determine your
+ # start location.
+ #
+ # This works with nesting since we're deleting tokens from the list once
+ # they've been used up. For example if you had nested module declarations
+ # then the innermost declaration would grab the last kw node that matches
+ # "module" (which would happen to be the innermost keyword). Then the outer
+ # one would only be able to grab the first one. In this way all of the
+ # tokens act as their own stack.
+ #
+ # If we're expecting to be able to find a token and consume it, but can't
+ # actually find it, then we need to raise an error. This is _usually_ caused
+ # by a syntax error in the source that we're printing. It could also be
+ # caused by accidentally attempting to consume a token twice by two
+ # different parser event handlers.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#254
+ def find_token(type); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#259
+ def find_token_between(type, left, right); end
+
+ # Returns the current location that is being looked at for the parser for
+ # the purpose of locating the error.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#210
+ def find_token_error(location); end
+
+ # Ripper doesn't support capturing lambda local variables until 3.2. To
+ # mitigate this, we have to parse that code for ourselves. We use the range
+ # from the parentheses to find where we _should_ be looking. Then we check
+ # if the resulting tokens match a pattern that we determine means that the
+ # declaration has block-local variables. Once it does, we parse those out
+ # and convert them into Ident nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2362
+ def lambda_locals(source); end
+
+ # Responsible for finding the nearest nodes to the given comment within the
+ # context of the given encapsulating node.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2946
+ def nearest_nodes(node, comment); end
+
+ # :call-seq:
+ # on_BEGIN: (Statements statements) -> BEGINBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#371
+ def on_BEGIN(statements); end
+
+ # :call-seq:
+ # on_CHAR: (String value) -> CHAR
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#395
+ def on_CHAR(value); end
+
+ # :call-seq:
+ # on_END: (Statements statements) -> ENDBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#410
+ def on_END(statements); end
+
+ # :call-seq:
+ # on___end__: (String value) -> EndContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#434
+ def on___end__(value); end
+
+ # :call-seq:
+ # on_alias: (
+ # (DynaSymbol | SymbolLiteral) left,
+ # (DynaSymbol | SymbolLiteral) right
+ # ) -> AliasNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#453
+ def on_alias(left, right); end
+
+ # If we encounter a parse error, just immediately bail out so that our
+ # runner can catch it.
+ #
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2863
+ def on_alias_error(error, *_arg1); end
+
+ # :call-seq:
+ # on_aref: (untyped collection, (nil | Args) index) -> ARef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#465
+ def on_aref(collection, index); end
+
+ # :call-seq:
+ # on_aref_field: (
+ # untyped collection,
+ # (nil | Args) index
+ # ) -> ARefField
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#481
+ def on_aref_field(collection, index); end
+
+ # :call-seq:
+ # on_arg_paren: (
+ # (nil | Args | ArgsForward) arguments
+ # ) -> ArgParen
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#500
+ def on_arg_paren(arguments); end
+
+ # :call-seq:
+ # on_args_add: (Args arguments, untyped argument) -> Args
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#522
+ def on_args_add(arguments, argument); end
+
+ # :call-seq:
+ # on_args_add_block: (
+ # Args arguments,
+ # (false | untyped) block
+ # ) -> Args
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#543
+ def on_args_add_block(arguments, block); end
+
+ # :call-seq:
+ # on_args_add_star: (Args arguments, untyped star) -> Args
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#581
+ def on_args_add_star(arguments, argument); end
+
+ # :call-seq:
+ # on_args_forward: () -> ArgsForward
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#603
+ def on_args_forward; end
+
+ # :call-seq:
+ # on_args_new: () -> Args
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#611
+ def on_args_new; end
+
+ # :call-seq:
+ # on_array: ((nil | Args) contents) ->
+ # ArrayLiteral | QSymbols | QWords | Symbols | Words
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#622
+ def on_array(contents); end
+
+ # :call-seq:
+ # on_aryptn: (
+ # (nil | VarRef) constant,
+ # (nil | Array[untyped]) requireds,
+ # (nil | VarField) rest,
+ # (nil | Array[untyped]) posts
+ # ) -> AryPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#701
+ def on_aryptn(constant, requireds, rest, posts); end
+
+ # :call-seq:
+ # on_assign: (
+ # (
+ # ARefField |
+ # ConstPathField |
+ # Field |
+ # TopConstField |
+ # VarField
+ # ) target,
+ # untyped value
+ # ) -> Assign
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#756
+ def on_assign(target, value); end
+
+ # If we encounter a parse error, just immediately bail out so that our
+ # runner can catch it.
+ #
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2863
+ def on_assign_error(error, *_arg1); end
+
+ # :call-seq:
+ # on_assoc_new: (untyped key, untyped value) -> Assoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#766
+ def on_assoc_new(key, value); end
+
+ # :call-seq:
+ # on_assoc_splat: (untyped value) -> AssocSplat
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#775
+ def on_assoc_splat(value); end
+
+ # :call-seq:
+ # on_backref: (String value) -> Backref
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#790
+ def on_backref(value); end
+
+ # :call-seq:
+ # on_backtick: (String value) -> Backtick
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#805
+ def on_backtick(value); end
+
+ # :call-seq:
+ # on_bare_assoc_hash: (
+ # Array[AssocNew | AssocSplat] assocs
+ # ) -> BareAssocHash
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#826
+ def on_bare_assoc_hash(assocs); end
+
+ # :call-seq:
+ # on_begin: (untyped bodystmt) -> Begin | PinnedBegin
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#835
+ def on_begin(bodystmt); end
+
+ # :call-seq:
+ # on_binary: (
+ # untyped left,
+ # (Op | Symbol) operator,
+ # untyped right
+ # ) -> Binary
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#874
+ def on_binary(left, operator, right); end
+
+ # :call-seq:
+ # on_block_var: (Params params, (nil | Array[Ident]) locals) -> BlockVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#906
+ def on_block_var(params, locals); end
+
+ # :call-seq:
+ # on_blockarg: (Ident name) -> BlockArg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#946
+ def on_blockarg(name); end
+
+ # :call-seq:
+ # on_bodystmt: (
+ # Statements statements,
+ # (nil | Rescue) rescue_clause,
+ # (nil | Statements) else_clause,
+ # (nil | Ensure) ensure_clause
+ # ) -> BodyStmt
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#962
+ def on_bodystmt(statements, rescue_clause, else_clause, ensure_clause); end
+
+ # :call-seq:
+ # on_brace_block: (
+ # (nil | BlockVar) block_var,
+ # Statements statements
+ # ) -> BlockNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#988
+ def on_brace_block(block_var, statements); end
+
+ # :call-seq:
+ # on_break: (Args arguments) -> Break
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1025
+ def on_break(arguments); end
+
+ # :call-seq:
+ # on_call: (
+ # untyped receiver,
+ # (:"::" | Op | Period) operator,
+ # (:call | Backtick | Const | Ident | Op) message
+ # ) -> CallNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1040
+ def on_call(receiver, operator, message); end
+
+ # :call-seq:
+ # on_case: (untyped value, untyped consequent) -> Case | RAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1061
+ def on_case(value, consequent); end
+
+ # :call-seq:
+ # on_class: (
+ # (ConstPathRef | ConstRef | TopConstRef) constant,
+ # untyped superclass,
+ # BodyStmt bodystmt
+ # ) -> ClassDeclaration
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1096
+ def on_class(constant, superclass, bodystmt); end
+
+ # If we encounter a parse error, just immediately bail out so that our
+ # runner can catch it.
+ #
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2863
+ def on_class_name_error(error, *_arg1); end
+
+ # :call-seq:
+ # on_comma: (String value) -> Comma
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1120
+ def on_comma(value); end
+
+ # :call-seq:
+ # on_command: ((Const | Ident) message, Args arguments) -> Command
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1139
+ def on_command(message, arguments); end
+
+ # :call-seq:
+ # on_command_call: (
+ # untyped receiver,
+ # (:"::" | Op | Period) operator,
+ # (Const | Ident | Op) message,
+ # (nil | Args) arguments
+ # ) -> CommandCall
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1155
+ def on_command_call(receiver, operator, message, arguments); end
+
+ # :call-seq:
+ # on_comment: (String value) -> Comment
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1170
+ def on_comment(value); end
+
+ # :call-seq:
+ # on_const: (String value) -> Const
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1208
+ def on_const(value); end
+
+ # :call-seq:
+ # on_const_path_field: (untyped parent, Const constant) ->
+ # ConstPathField | Field
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1224
+ def on_const_path_field(parent, constant); end
+
+ # :call-seq:
+ # on_const_path_ref: (untyped parent, Const constant) -> ConstPathRef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1243
+ def on_const_path_ref(parent, constant); end
+
+ # :call-seq:
+ # on_const_ref: (Const constant) -> ConstRef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1253
+ def on_const_ref(constant); end
+
+ # :call-seq:
+ # on_cvar: (String value) -> CVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1259
+ def on_cvar(value); end
+
+ # :call-seq:
+ # on_def: (
+ # (Backtick | Const | Ident | Kw | Op) name,
+ # (nil | Params | Paren) params,
+ # untyped bodystmt
+ # ) -> DefNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1278
+ def on_def(name, params, bodystmt); end
+
+ # :call-seq:
+ # on_defined: (untyped value) -> Defined
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1346
+ def on_defined(value); end
+
+ # :call-seq:
+ # on_defs: (
+ # untyped target,
+ # (Op | Period) operator,
+ # (Backtick | Const | Ident | Kw | Op) name,
+ # (Params | Paren) params,
+ # BodyStmt bodystmt
+ # ) -> DefNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1370
+ def on_defs(target, operator, name, params, bodystmt); end
+
+ # :call-seq:
+ # on_do_block: (BlockVar block_var, BodyStmt bodystmt) -> BlockNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1435
+ def on_do_block(block_var, bodystmt); end
+
+ # :call-seq:
+ # on_dot2: ((nil | untyped) left, (nil | untyped) right) -> RangeNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1459
+ def on_dot2(left, right); end
+
+ # :call-seq:
+ # on_dot3: ((nil | untyped) left, (nil | untyped) right) -> RangeNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1475
+ def on_dot3(left, right); end
+
+ # :call-seq:
+ # on_dyna_symbol: (StringContent string_content) -> DynaSymbol
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1491
+ def on_dyna_symbol(string_content); end
+
+ # :call-seq:
+ # on_else: (Statements statements) -> Else
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1517
+ def on_else(statements); end
+
+ # :call-seq:
+ # on_elsif: (
+ # untyped predicate,
+ # Statements statements,
+ # (nil | Elsif | Else) consequent
+ # ) -> Elsif
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1558
+ def on_elsif(predicate, statements, consequent); end
+
+ # :call-seq:
+ # on_embdoc: (String value) -> EmbDoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1588
+ def on_embdoc(value); end
+
+ # :call-seq:
+ # on_embdoc_beg: (String value) -> EmbDoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1595
+ def on_embdoc_beg(value); end
+
+ # :call-seq:
+ # on_embdoc_end: (String value) -> EmbDoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1606
+ def on_embdoc_end(value); end
+
+ # :call-seq:
+ # on_embexpr_beg: (String value) -> EmbExprBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1630
+ def on_embexpr_beg(value); end
+
+ # :call-seq:
+ # on_embexpr_end: (String value) -> EmbExprEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1649
+ def on_embexpr_end(value); end
+
+ # :call-seq:
+ # on_embvar: (String value) -> EmbVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1668
+ def on_embvar(value); end
+
+ # :call-seq:
+ # on_ensure: (Statements statements) -> Ensure
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1687
+ def on_ensure(statements); end
+
+ # The handler for this event accepts no parameters (though in previous
+ # versions of Ruby it accepted a string literal with a value of ",").
+ #
+ # :call-seq:
+ # on_excessed_comma: () -> ExcessedComma
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1714
+ def on_excessed_comma(*_arg0); end
+
+ # :call-seq:
+ # on_fcall: ((Const | Ident) value) -> CallNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1722
+ def on_fcall(value); end
+
+ # :call-seq:
+ # on_field: (
+ # untyped parent,
+ # (:"::" | Op | Period) operator
+ # (Const | Ident) name
+ # ) -> Field
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1738
+ def on_field(parent, operator, name); end
+
+ # :call-seq:
+ # on_float: (String value) -> FloatLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1749
+ def on_float(value); end
+
+ # :call-seq:
+ # on_fndptn: (
+ # (nil | untyped) constant,
+ # VarField left,
+ # Array[untyped] values,
+ # VarField right
+ # ) -> FndPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1769
+ def on_fndptn(constant, left, values, right); end
+
+ # :call-seq:
+ # on_for: (
+ # (MLHS | VarField) value,
+ # untyped collection,
+ # Statements statements
+ # ) -> For
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1821
+ def on_for(index, collection, statements); end
+
+ # :call-seq:
+ # on_gvar: (String value) -> GVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1859
+ def on_gvar(value); end
+
+ # :call-seq:
+ # on_hash: ((nil | Array[AssocNew | AssocSplat]) assocs) -> HashLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1874
+ def on_hash(assocs); end
+
+ # :call-seq:
+ # on_heredoc_beg: (String value) -> HeredocBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1887
+ def on_heredoc_beg(value); end
+
+ # :call-seq:
+ # on_heredoc_dedent: (StringContent string, Integer width) -> Heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1906
+ def on_heredoc_dedent(string, width); end
+
+ # :call-seq:
+ # on_heredoc_end: (String value) -> Heredoc
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1920
+ def on_heredoc_end(value); end
+
+ # :call-seq:
+ # on_hshptn: (
+ # (nil | untyped) constant,
+ # Array[[Label | StringContent, untyped]] keywords,
+ # (nil | VarField) keyword_rest
+ # ) -> HshPtn
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#1956
+ def on_hshptn(constant, keywords, keyword_rest); end
+
+ # :call-seq:
+ # on_ident: (String value) -> Ident
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2026
+ def on_ident(value); end
+
+ # :call-seq:
+ # on_if: (
+ # untyped predicate,
+ # Statements statements,
+ # (nil | Elsif | Else) consequent
+ # ) -> IfNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2045
+ def on_if(predicate, statements, consequent); end
+
+ # :call-seq:
+ # on_if_mod: (untyped predicate, untyped statement) -> IfNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2085
+ def on_if_mod(predicate, statement); end
+
+ # :call-seq:
+ # on_ifop: (untyped predicate, untyped truthy, untyped falsy) -> IfOp
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2074
+ def on_ifop(predicate, truthy, falsy); end
+
+ # :call-seq:
+ # on_imaginary: (String value) -> Imaginary
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2107
+ def on_imaginary(value); end
+
+ # :call-seq:
+ # on_in: (RAssign pattern, nil statements, nil consequent) -> RAssign
+ # | (
+ # untyped pattern,
+ # Statements statements,
+ # (nil | In | Else) consequent
+ # ) -> In
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2127
+ def on_in(pattern, statements, consequent); end
+
+ # :call-seq:
+ # on_int: (String value) -> Int
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2172
+ def on_int(value); end
+
+ # :call-seq:
+ # on_ivar: (String value) -> IVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2187
+ def on_ivar(value); end
+
+ # :call-seq:
+ # on_kw: (String value) -> Kw
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2202
+ def on_kw(value); end
+
+ # :call-seq:
+ # on_kwrest_param: ((nil | Ident) name) -> KwRestParam
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2221
+ def on_kwrest_param(name); end
+
+ # :call-seq:
+ # on_label: (String value) -> Label
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2230
+ def on_label(value); end
+
+ # :call-seq:
+ # on_label_end: (String value) -> LabelEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2245
+ def on_label_end(value); end
+
+ # :call-seq:
+ # on_lambda: (
+ # (Params | Paren) params,
+ # (BodyStmt | Statements) statements
+ # ) -> Lambda
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2267
+ def on_lambda(params, statements); end
+
+ # :call-seq:
+ # on_lambda_var: (Params params, Array[ Ident ] locals) -> LambdaVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2349
+ def on_lambda_var(params, locals); end
+
+ # :call-seq:
+ # on_lbrace: (String value) -> LBrace
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2432
+ def on_lbrace(value); end
+
+ # :call-seq:
+ # on_lbracket: (String value) -> LBracket
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2451
+ def on_lbracket(value); end
+
+ # :call-seq:
+ # on_lparen: (String value) -> LParen
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2470
+ def on_lparen(value); end
+
+ # :call-seq:
+ # on_massign: ((MLHS | MLHSParen) target, untyped value) -> MAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2493
+ def on_massign(target, value); end
+
+ # :call-seq:
+ # on_method_add_arg: (
+ # CallNode call,
+ # (ArgParen | Args) arguments
+ # ) -> CallNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2509
+ def on_method_add_arg(call, arguments); end
+
+ # :call-seq:
+ # on_method_add_block: (
+ # (Break | Call | Command | CommandCall, Next) call,
+ # Block block
+ # ) -> Break | MethodAddBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2527
+ def on_method_add_block(call, block); end
+
+ # :call-seq:
+ # on_mlhs_add: (
+ # MLHS mlhs,
+ # (ARefField | Field | Ident | MLHSParen | VarField) part
+ # ) -> MLHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2556
+ def on_mlhs_add(mlhs, part); end
+
+ # :call-seq:
+ # on_mlhs_add_post: (MLHS left, MLHS right) -> MLHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2565
+ def on_mlhs_add_post(left, right); end
+
+ # :call-seq:
+ # on_mlhs_add_star: (
+ # MLHS mlhs,
+ # (nil | ARefField | Field | Ident | VarField) part
+ # ) -> MLHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2577
+ def on_mlhs_add_star(mlhs, part); end
+
+ # :call-seq:
+ # on_mlhs_new: () -> MLHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2590
+ def on_mlhs_new; end
+
+ # :call-seq:
+ # on_mlhs_paren: ((MLHS | MLHSParen) contents) -> MLHSParen
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2600
+ def on_mlhs_paren(contents); end
+
+ # :call-seq:
+ # on_module: (
+ # (ConstPathRef | ConstRef | TopConstRef) constant,
+ # BodyStmt bodystmt
+ # ) -> ModuleDeclaration
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2618
+ def on_module(constant, bodystmt); end
+
+ # :call-seq:
+ # on_mrhs_add: (MRHS mrhs, untyped part) -> MRHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2650
+ def on_mrhs_add(mrhs, part); end
+
+ # :call-seq:
+ # on_mrhs_add_star: (MRHS mrhs, untyped value) -> MRHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2659
+ def on_mrhs_add_star(mrhs, value); end
+
+ # :call-seq:
+ # on_mrhs_new: () -> MRHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2640
+ def on_mrhs_new; end
+
+ # :call-seq:
+ # on_mrhs_new_from_args: (Args arguments) -> MRHS
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2681
+ def on_mrhs_new_from_args(arguments); end
+
+ # :call-seq:
+ # on_next: (Args arguments) -> Next
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2687
+ def on_next(arguments); end
+
+ # :call-seq:
+ # on_op: (String value) -> Op
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2706
+ def on_op(value); end
+
+ # :call-seq:
+ # on_opassign: (
+ # (
+ # ARefField |
+ # ConstPathField |
+ # Field |
+ # TopConstField |
+ # VarField
+ # ) target,
+ # Op operator,
+ # untyped value
+ # ) -> OpAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2735
+ def on_opassign(target, operator, value); end
+
+ # If we encounter a parse error, just immediately bail out so that our
+ # runner can catch it.
+ #
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2863
+ def on_param_error(error, *_arg1); end
+
+ # :call-seq:
+ # on_params: (
+ # (nil | Array[Ident]) requireds,
+ # (nil | Array[[Ident, untyped]]) optionals,
+ # (nil | ArgsForward | ExcessedComma | RestParam) rest,
+ # (nil | Array[Ident]) posts,
+ # (nil | Array[[Ident, nil | untyped]]) keywords,
+ # (nil | :nil | ArgsForward | KwRestParam) keyword_rest,
+ # (nil | :& | BlockArg) block
+ # ) -> Params
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2758
+ def on_params(requireds, optionals, rest, posts, keywords, keyword_rest, block); end
+
+ # :call-seq:
+ # on_paren: (untyped contents) -> Paren
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2823
+ def on_paren(contents); end
+
+ # If we encounter a parse error, just immediately bail out so that our
+ # runner can catch it.
+ #
+ # @raise [ParseError]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2863
+ def on_parse_error(error, *_arg1); end
+
+ # :call-seq:
+ # on_period: (String value) -> Period
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2873
+ def on_period(value); end
+
+ # :call-seq:
+ # on_program: (Statements statements) -> Program
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#2888
+ def on_program(statements); end
+
+ # :call-seq:
+ # on_qsymbols_add: (QSymbols qsymbols, TStringContent element) -> QSymbols
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3000
+ def on_qsymbols_add(qsymbols, element); end
+
+ # :call-seq:
+ # on_qsymbols_beg: (String value) -> QSymbolsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3010
+ def on_qsymbols_beg(value); end
+
+ # :call-seq:
+ # on_qsymbols_new: () -> QSymbols
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3029
+ def on_qsymbols_new; end
+
+ # :call-seq:
+ # on_qwords_add: (QWords qwords, TStringContent element) -> QWords
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3041
+ def on_qwords_add(qwords, element); end
+
+ # :call-seq:
+ # on_qwords_beg: (String value) -> QWordsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3051
+ def on_qwords_beg(value); end
+
+ # :call-seq:
+ # on_qwords_new: () -> QWords
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3070
+ def on_qwords_new; end
+
+ # :call-seq:
+ # on_rational: (String value) -> RationalLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3082
+ def on_rational(value); end
+
+ # :call-seq:
+ # on_rbrace: (String value) -> RBrace
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3097
+ def on_rbrace(value); end
+
+ # :call-seq:
+ # on_rbracket: (String value) -> RBracket
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3116
+ def on_rbracket(value); end
+
+ # :call-seq:
+ # on_redo: () -> Redo
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3135
+ def on_redo; end
+
+ # :call-seq:
+ # on_regexp_add: (
+ # RegexpContent regexp_content,
+ # (StringDVar | StringEmbExpr | TStringContent) part
+ # ) -> RegexpContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3146
+ def on_regexp_add(regexp_content, part); end
+
+ # :call-seq:
+ # on_regexp_beg: (String value) -> RegexpBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3156
+ def on_regexp_beg(value); end
+
+ # :call-seq:
+ # on_regexp_end: (String value) -> RegexpEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3175
+ def on_regexp_end(value); end
+
+ # :call-seq:
+ # on_regexp_literal: (
+ # RegexpContent regexp_content,
+ # (nil | RegexpEnd) ending
+ # ) -> RegexpLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3193
+ def on_regexp_literal(regexp_content, ending); end
+
+ # :call-seq:
+ # on_regexp_new: () -> RegexpContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3211
+ def on_regexp_new; end
+
+ # :call-seq:
+ # on_rescue: (
+ # (nil | [untyped] | MRHS | MRHSAddStar) exceptions,
+ # (nil | Field | VarField) variable,
+ # Statements statements,
+ # (nil | Rescue) consequent
+ # ) -> Rescue
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3228
+ def on_rescue(exceptions, variable, statements, consequent); end
+
+ # :call-seq:
+ # on_rescue_mod: (untyped statement, untyped value) -> RescueMod
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3281
+ def on_rescue_mod(statement, value); end
+
+ # :call-seq:
+ # on_rest_param: ((nil | Ident) name) -> RestParam
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3293
+ def on_rest_param(name); end
+
+ # :call-seq:
+ # on_retry: () -> Retry
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3302
+ def on_retry; end
+
+ # :call-seq:
+ # on_return: (Args arguments) -> ReturnNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3310
+ def on_return(arguments); end
+
+ # :call-seq:
+ # on_return0: () -> ReturnNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3321
+ def on_return0; end
+
+ # :call-seq:
+ # on_rparen: (String value) -> RParen
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3329
+ def on_rparen(value); end
+
+ # :call-seq:
+ # on_sclass: (untyped target, BodyStmt bodystmt) -> SClass
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3348
+ def on_sclass(target, bodystmt); end
+
+ # :call-seq:
+ # on_semicolon: (String value) -> Semicolon
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3381
+ def on_semicolon(value); end
+
+ # stmts_add is a parser event that represents a single statement inside a
+ # list of statements within any lexical block. It accepts as arguments the
+ # parent stmts node as well as an stmt which can be any expression in
+ # Ruby.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3400
+ def on_stmts_add(statements, statement); end
+
+ # :call-seq:
+ # on_stmts_new: () -> Statements
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3413
+ def on_stmts_new; end
+
+ # :call-seq:
+ # on_string_add: (
+ # String string,
+ # (StringEmbExpr | StringDVar | TStringContent) part
+ # ) -> StringContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3426
+ def on_string_add(string, part); end
+
+ # :call-seq:
+ # on_string_concat: (
+ # (StringConcat | StringLiteral) left,
+ # StringLiteral right
+ # ) -> StringConcat
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3443
+ def on_string_concat(left, right); end
+
+ # :call-seq:
+ # on_string_content: () -> StringContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3453
+ def on_string_content; end
+
+ # :call-seq:
+ # on_string_dvar: ((Backref | VarRef) variable) -> StringDVar
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3463
+ def on_string_dvar(variable); end
+
+ # :call-seq:
+ # on_string_embexpr: (Statements statements) -> StringEmbExpr
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3474
+ def on_string_embexpr(statements); end
+
+ # :call-seq:
+ # on_string_literal: (String string) -> Heredoc | StringLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3504
+ def on_string_literal(string); end
+
+ # :call-seq:
+ # on_super: ((ArgParen | Args) arguments) -> Super
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3544
+ def on_super(arguments); end
+
+ # symbeg is a token that represents the beginning of a symbol literal. In
+ # most cases it will contain just ":" as in the value, but if its a dynamic
+ # symbol being defined it will contain ":'" or ":\"".
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3556
+ def on_symbeg(value); end
+
+ # :call-seq:
+ # on_symbol: (
+ # (Backtick | Const | CVar | GVar | Ident | IVar | Kw | Op) value
+ # ) -> SymbolContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3577
+ def on_symbol(value); end
+
+ # :call-seq:
+ # on_symbol_literal: (
+ # (
+ # Backtick | Const | CVar | GVar | Ident |
+ # IVar | Kw | Op | SymbolContent
+ # ) value
+ # ) -> SymbolLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3590
+ def on_symbol_literal(value); end
+
+ # :call-seq:
+ # on_symbols_add: (Symbols symbols, Word word) -> Symbols
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3606
+ def on_symbols_add(symbols, word); end
+
+ # :call-seq:
+ # on_symbols_beg: (String value) -> SymbolsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3616
+ def on_symbols_beg(value); end
+
+ # :call-seq:
+ # on_symbols_new: () -> Symbols
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3635
+ def on_symbols_new; end
+
+ # :call-seq:
+ # on_tlambda: (String value) -> TLambda
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3647
+ def on_tlambda(value); end
+
+ # :call-seq:
+ # on_tlambeg: (String value) -> TLamBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3666
+ def on_tlambeg(value); end
+
+ # :call-seq:
+ # on_top_const_field: (Const constant) -> TopConstRef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3685
+ def on_top_const_field(constant); end
+
+ # :call-seq:
+ # on_top_const_ref: (Const constant) -> TopConstRef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3696
+ def on_top_const_ref(constant); end
+
+ # :call-seq:
+ # on_tstring_beg: (String value) -> TStringBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3707
+ def on_tstring_beg(value); end
+
+ # :call-seq:
+ # on_tstring_content: (String value) -> TStringContent
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3726
+ def on_tstring_content(value); end
+
+ # :call-seq:
+ # on_tstring_end: (String value) -> TStringEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3741
+ def on_tstring_end(value); end
+
+ # :call-seq:
+ # on_unary: (:not operator, untyped statement) -> Not
+ # | (Symbol operator, untyped statement) -> Unary
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3761
+ def on_unary(operator, statement); end
+
+ # :call-seq:
+ # on_undef: (Array[DynaSymbol | SymbolLiteral] symbols) -> Undef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3804
+ def on_undef(symbols); end
+
+ # :call-seq:
+ # on_unless: (
+ # untyped predicate,
+ # Statements statements,
+ # ((nil | Elsif | Else) consequent)
+ # ) -> UnlessNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3819
+ def on_unless(predicate, statements, consequent); end
+
+ # :call-seq:
+ # on_unless_mod: (untyped predicate, untyped statement) -> UnlessNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3848
+ def on_unless_mod(predicate, statement); end
+
+ # :call-seq:
+ # on_until: (untyped predicate, Statements statements) -> UntilNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3862
+ def on_until(predicate, statements); end
+
+ # :call-seq:
+ # on_until_mod: (untyped predicate, untyped statement) -> UntilNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3893
+ def on_until_mod(predicate, statement); end
+
+ # :call-seq:
+ # on_var_alias: (GVar left, (Backref | GVar) right) -> AliasNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3906
+ def on_var_alias(left, right); end
+
+ # :call-seq:
+ # on_var_field: (
+ # (nil | Const | CVar | GVar | Ident | IVar) value
+ # ) -> VarField
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3920
+ def on_var_field(value); end
+
+ # :call-seq:
+ # on_var_ref: ((Const | CVar | GVar | Ident | IVar | Kw) value) -> VarRef
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3935
+ def on_var_ref(value); end
+
+ # :call-seq:
+ # on_vcall: (Ident ident) -> VCall
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3941
+ def on_vcall(ident); end
+
+ # :call-seq:
+ # on_void_stmt: () -> VoidStmt
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3947
+ def on_void_stmt; end
+
+ # :call-seq:
+ # on_when: (
+ # Args arguments,
+ # Statements statements,
+ # (nil | Else | When) consequent
+ # ) -> When
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3960
+ def on_when(arguments, statements, consequent); end
+
+ # :call-seq:
+ # on_while: (untyped predicate, Statements statements) -> WhileNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3992
+ def on_while(predicate, statements); end
+
+ # :call-seq:
+ # on_while_mod: (untyped predicate, untyped statement) -> WhileNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4023
+ def on_while_mod(predicate, statement); end
+
+ # :call-seq:
+ # on_word_add: (
+ # Word word,
+ # (StringEmbExpr | StringDVar | TStringContent) part
+ # ) -> Word
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4039
+ def on_word_add(word, part); end
+
+ # :call-seq:
+ # on_word_new: () -> Word
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4048
+ def on_word_new; end
+
+ # :call-seq:
+ # on_words_add: (Words words, Word word) -> Words
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4058
+ def on_words_add(words, word); end
+
+ # :call-seq:
+ # on_words_beg: (String value) -> WordsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4068
+ def on_words_beg(value); end
+
+ # :call-seq:
+ # on_words_new: () -> Words
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4087
+ def on_words_new; end
+
+ # :call-seq:
+ # on_xstring_add: (
+ # XString xstring,
+ # (StringEmbExpr | StringDVar | TStringContent) part
+ # ) -> XString
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4106
+ def on_xstring_add(xstring, part); end
+
+ # :call-seq:
+ # on_xstring_literal: (XString xstring) -> Heredoc | XStringLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4130
+ def on_xstring_literal(xstring); end
+
+ # :call-seq:
+ # on_xstring_new: () -> XString
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4115
+ def on_xstring_new; end
+
+ # :call-seq:
+ # on_yield: ((Args | Paren) arguments) -> YieldNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4153
+ def on_yield(arguments); end
+
+ # :call-seq:
+ # on_yield0: () -> YieldNode
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4164
+ def on_yield0; end
+
+ # :call-seq:
+ # on_zsuper: () -> ZSuper
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#4172
+ def on_zsuper; end
+end
+
+# Represents a line in the source. If this class is being used, it means
+# that there are characters in the string that are multi-byte, so we will
+# build up an array of indices, such that array[byteindex] will be equal to
+# the index of the character within the string.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#38
+class SyntaxTree::Parser::MultiByteString
+ # @return [MultiByteString] a new instance of MultiByteString
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#41
+ def initialize(start, line); end
+
+ # Technically it's possible for the column index to be a negative value if
+ # there's a BOM at the beginning of the file, which is the reason we need
+ # to compare it to 0 here.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#55
+ def [](byteindex); end
+
+ # Returns the value of attribute indices.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#39
+ def indices; end
+
+ # Returns the value of attribute start.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#39
+ def start; end
+end
+
+# A special parser error so that we can get nice syntax displays on the
+# error message when prettier prints out the results.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#9
+class SyntaxTree::Parser::ParseError < ::StandardError
+ # @return [ParseError] a new instance of ParseError
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#12
+ def initialize(error, lineno, column); end
+
+ # Returns the value of attribute column.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#10
+ def column; end
+
+ # Returns the value of attribute lineno.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#10
+ def lineno; end
+end
+
+# Ugh... I really do not like this class. Basically, ripper doesn't provide
+# enough information about where pins are located in the tree. It only gives
+# events for ^ ops and var_ref nodes. You have to piece it together
+# yourself.
+#
+# Note that there are edge cases here that we straight up do not address,
+# because I honestly think it's going to be faster to write a new parser
+# than to address them. For example, this will not work properly:
+#
+# foo in ^((bar = 0; bar; baz))
+#
+# If someone actually does something like that, we'll have to find another
+# way to make this work.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#656
+class SyntaxTree::Parser::PinVisitor < ::SyntaxTree::Visitor
+ # @return [PinVisitor] a new instance of PinVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#659
+ def initialize(pins); end
+
+ # Returns the value of attribute pins.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#657
+ def pins; end
+
+ # Returns the value of attribute stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#657
+ def stack; end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#664
+ def visit(node); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#672
+ def visit_var_ref(node); end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/parser.rb#677
+ def visit(node, tokens); end
+ end
+end
+
+# Semicolons are tokens that get added to the token list but never get
+# attached to the AST. Because of this they only need to track their
+# associated location so they can be used for computing bounds.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#3371
+class SyntaxTree::Parser::Semicolon
+ # @return [Semicolon] a new instance of Semicolon
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3374
+ def initialize(location); end
+
+ # Returns the value of attribute location.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#3372
+ def location; end
+end
+
+# Represents a line in the source. If this class is being used, it means
+# that every character in the string is 1 byte in length, so we can just
+# return the start of the line + the index.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#22
+class SyntaxTree::Parser::SingleByteString
+ # @return [SingleByteString] a new instance of SingleByteString
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#25
+ def initialize(start); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#29
+ def [](byteindex); end
+
+ # Returns the value of attribute start.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#23
+ def start; end
+end
+
+# This represents all of the tokens coming back from the lexer. It is
+# replacing a simple array because it keeps track of the last deleted token
+# from the list for better error messages.
+#
+# source://syntax_tree//lib/syntax_tree/parser.rb#63
+class SyntaxTree::Parser::TokenList
+ # @return [TokenList] a new instance of TokenList
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#66
+ def initialize; end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#71
+ def <<(token); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#75
+ def [](index); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#79
+ def any?(&block); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#91
+ def delete(value); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#95
+ def delete_at(index); end
+
+ # Returns the value of attribute last_deleted.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#64
+ def last_deleted; end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#83
+ def reverse_each(&block); end
+
+ # source://syntax_tree//lib/syntax_tree/parser.rb#87
+ def rindex(&block); end
+
+ # Returns the value of attribute tokens.
+ #
+ # source://syntax_tree//lib/syntax_tree/parser.rb#64
+ def tokens; 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 Const[value: "SyntaxTree"]
+# end
+#
+# the pattern is the `Const[value: "SyntaxTree"]` expression. Within Syntax
+# Tree, every node generates these kinds of expressions using the
+# #construct_keys method.
+#
+# The pattern gets compiled into an object that responds to call by running
+# the #compile method. This method itself will run back through Syntax Tree 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 = SyntaxTree::Pattern.new("Const[value: 'SyntaxTree']").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 SyntaxTree::Pattern::CompilationError will be
+# raised.
+#
+# source://syntax_tree//lib/syntax_tree/pattern.rb#39
+class SyntaxTree::Pattern
+ # @return [Pattern] a new instance of Pattern
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#61
+ def initialize(query); end
+
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#65
+ def compile; end
+
+ # Returns the value of attribute query.
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#59
+ def query; end
+
+ private
+
+ # Shortcut for combining two procs into one that returns true if both return
+ # true.
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#80
+ def combine_and(left, right); end
+
+ # Shortcut for combining two procs into one that returns true if either
+ # returns true.
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#86
+ def combine_or(left, right); end
+
+ # in [foo, bar, baz]
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#109
+ def compile_aryptn(node); end
+
+ # in foo | bar
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#134
+ def compile_binary(node); end
+
+ # in Ident
+ # in String
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#142
+ def compile_const(node); end
+
+ # in SyntaxTree::Ident
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#159
+ def compile_const_path_ref(node); end
+
+ # in :""
+ # in :"foo"
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#172
+ def compile_dyna_symbol(node); end
+
+ # Raise an error because the given node is not supported.
+ #
+ # @raise [CompilationError]
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#91
+ def compile_error(node); end
+
+ # in Ident[value: String]
+ # in { value: String }
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#188
+ def compile_hshptn(node); end
+
+ # Compile any kind of node. Dispatch out to the individual compilation
+ # methods based on the type of node.
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#260
+ def compile_node(node); end
+
+ # in /foo/
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#214
+ def compile_regexp_literal(node); end
+
+ # in ""
+ # in "foo"
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#226
+ def compile_string_literal(node); end
+
+ # in :+
+ # in :foo
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#238
+ def compile_symbol_literal(node); end
+
+ # in Foo
+ # in nil
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#246
+ def compile_var_ref(node); end
+
+ # There are a couple of nodes (string literals, dynamic symbols, and regexp)
+ # that contain list of parts. This can include plain string content,
+ # interpolated expressions, and interpolated variables. We only support
+ # plain string content, so this method will extract out the plain string
+ # content if it is the only element in the list.
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#100
+ def extract_string(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://syntax_tree//lib/syntax_tree/pattern.rb#42
+class SyntaxTree::Pattern::CompilationError < ::StandardError
+ # @return [CompilationError] a new instance of CompilationError
+ #
+ # source://syntax_tree//lib/syntax_tree/pattern.rb#43
+ def initialize(repr); end
+end
+
+# Period represents the use of the +.+ operator. It is usually found in method
+# calls.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8553
+class SyntaxTree::Period < ::SyntaxTree::Node
+ # @return [Period] a new instance of Period
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8560
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8595
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8566
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8570
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8558
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8574
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8570
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8587
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8591
+ def format(q); end
+
+ # [String] the period
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8555
+ def value; end
+end
+
+# PinnedBegin represents a pinning a nested statement within pattern matching.
+#
+# case value
+# in ^(statement)
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#1962
+class SyntaxTree::PinnedBegin < ::SyntaxTree::Node
+ # @return [PinnedBegin] a new instance of PinnedBegin
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1969
+ def initialize(statement:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2014
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1975
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1979
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1967
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1983
+ def copy(statement: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1979
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#1996
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#2000
+ def format(q); end
+
+ # [Node] the expression being pinned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#1964
+ def statement; end
+end
+
+# PinnedVarRef represents a pinned variable reference within a pattern
+# matching pattern.
+#
+# case value
+# in ^variable
+# end
+#
+# This can be a plain local variable like the example above. It can also be a
+# a class variable, a global variable, or an instance variable.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11661
+class SyntaxTree::PinnedVarRef < ::SyntaxTree::Node
+ # @return [PinnedVarRef] a new instance of PinnedVarRef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11668
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11706
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11674
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11678
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11666
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11682
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11678
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11695
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11699
+ def format(q); end
+
+ # [Const | CVar | GVar | Ident | IVar] the value of this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11663
+ def value; end
+end
+
+# This visitor pretty-prints the AST into an equivalent s-expression.
+#
+# source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#5
+class SyntaxTree::PrettyPrintVisitor < ::SyntaxTree::FieldVisitor
+ # @return [PrettyPrintVisitor] a new instance of PrettyPrintVisitor
+ #
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#8
+ def initialize(q); end
+
+ # Returns the value of attribute q.
+ #
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#6
+ def q; end
+
+ # This is here because we need to make sure the operator is cast to a string
+ # before we print it out.
+ #
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#14
+ def visit_binary(node); end
+
+ # This is here to make it a little nicer to look at labels since they
+ # typically have their : at the end of the value.
+ #
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#25
+ def visit_label(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#36
+ def comments(node); end
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#45
+ def field(_name, value); end
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#50
+ def list(_name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#55
+ def node(_node, type); end
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#62
+ def pairs(_name, values); end
+
+ # source://syntax_tree//lib/syntax_tree/pretty_print_visitor.rb#78
+ def text(_name, value); end
+end
+
+# Program represents the overall syntax tree.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8601
+class SyntaxTree::Program < ::SyntaxTree::Node
+ # @return [Program] a new instance of Program
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8608
+ def initialize(statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8648
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8614
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8618
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8606
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8622
+ def copy(statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8618
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8635
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8639
+ def format(q); end
+
+ # [Statements] the top-level expressions of the program
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8603
+ def statements; end
+end
+
+# QSymbols represents a symbol literal array without interpolation.
+#
+# %i[one two three]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8657
+class SyntaxTree::QSymbols < ::SyntaxTree::Node
+ # @return [QSymbols] a new instance of QSymbols
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8667
+ def initialize(beginning:, elements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8727
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8674
+ def accept(visitor); end
+
+ # [QSymbolsBeg] the token that opens this array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8659
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8678
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8665
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8682
+ def copy(beginning: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8678
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8696
+ def deconstruct_keys(_keys); end
+
+ # [Array[ TStringContent ]] the elements of the array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8662
+ def elements; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8705
+ def format(q); end
+end
+
+# QSymbolsBeg represents the beginning of a symbol literal array.
+#
+# %i[one two three]
+#
+# In the snippet above, QSymbolsBeg represents the "%i[" token. Note that
+# these kinds of arrays can start with a lot of different delimiter types
+# (e.g., %i| or %i<).
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8740
+class SyntaxTree::QSymbolsBeg < ::SyntaxTree::Node
+ # @return [QSymbolsBeg] a new instance of QSymbolsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8744
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8770
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8749
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8753
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8757
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8753
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8766
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8742
+ def value; end
+end
+
+# QWords represents a string literal array without interpolation.
+#
+# %w[one two three]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8779
+class SyntaxTree::QWords < ::SyntaxTree::Node
+ # @return [QWords] a new instance of QWords
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8789
+ def initialize(beginning:, elements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8845
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8796
+ def accept(visitor); end
+
+ # [QWordsBeg] the token that opens this array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8781
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8800
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8787
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8804
+ def copy(beginning: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8800
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8814
+ def deconstruct_keys(_keys); end
+
+ # [Array[ TStringContent ]] the elements of the array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8784
+ def elements; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8823
+ def format(q); end
+end
+
+# QWordsBeg represents the beginning of a string literal array.
+#
+# %w[one two three]
+#
+# In the snippet above, QWordsBeg represents the "%w[" token. Note that these
+# kinds of arrays can start with a lot of different delimiter types (e.g.,
+# %w| or %w<).
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8858
+class SyntaxTree::QWordsBeg < ::SyntaxTree::Node
+ # @return [QWordsBeg] a new instance of QWordsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8862
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8888
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8867
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8871
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8875
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8871
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8884
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8860
+ def value; end
+end
+
+# Responsible for providing information about quotes to be used for strings
+# and dynamic symbols.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4615
+module SyntaxTree::Quotes
+ class << self
+ # If there is some part of this string that matches an escape sequence or
+ # that contains the interpolation pattern ("#{"), then we are locked into
+ # whichever quote the user chose. (If they chose single quotes, then double
+ # quoting would activate the escape sequence, and if they chose double
+ # quotes, then single quotes would deactivate it.)
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4624
+ def locked?(node, quote); end
+
+ # Find the matching closing quote for the given opening quote.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4631
+ def matching(quote); end
+
+ # Escape and unescape single and double quotes as needed to be able to
+ # enclose +content+ with +enclosing+.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4637
+ def normalize(content, enclosing); end
+ end
+end
+
+# The matching pairs of quotes that can be used with % literals.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4617
+SyntaxTree::Quotes::PAIRS = T.let(T.unsafe(nil), Hash)
+
+# RAssign represents a single-line pattern match.
+#
+# value in pattern
+# value => pattern
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#3201
+class SyntaxTree::RAssign < ::SyntaxTree::Node
+ # @return [RAssign] a new instance of RAssign
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3215
+ def initialize(value:, operator:, pattern:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3277
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3223
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3227
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3213
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3231
+ def copy(value: T.unsafe(nil), operator: T.unsafe(nil), pattern: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3227
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3246
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#3256
+ def format(q); end
+
+ # [Kw | Op] the operator being used to match against the pattern, which is
+ # either => or in
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3207
+ def operator; end
+
+ # [Node] the pattern on the right-hand side of the expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3210
+ def pattern; end
+
+ # [Node] the left-hand expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#3203
+ def value; end
+end
+
+# RBrace represents the use of a right brace, i.e., +++.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8945
+class SyntaxTree::RBrace < ::SyntaxTree::Node
+ # @return [RBrace] a new instance of RBrace
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8949
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8975
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8954
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8958
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8962
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8958
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8971
+ def deconstruct_keys(_keys); end
+
+ # [String] the right brace
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8947
+ def value; end
+end
+
+# RBracket represents the use of a right bracket, i.e., +]+.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8981
+class SyntaxTree::RBracket < ::SyntaxTree::Node
+ # @return [RBracket] a new instance of RBracket
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8985
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9011
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8990
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8994
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8998
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8994
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9007
+ def deconstruct_keys(_keys); end
+
+ # [String] the right bracket
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8983
+ def value; end
+end
+
+# RParen represents the use of a right parenthesis, i.e., +)+.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9751
+class SyntaxTree::RParen < ::SyntaxTree::Node
+ # @return [RParen] a new instance of RParen
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9755
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9781
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9760
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9764
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9768
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9764
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9777
+ def deconstruct_keys(_keys); end
+
+ # [String] the parenthesis
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9753
+ def value; end
+end
+
+# RangeNode represents using the .. or the ... operator between two
+# expressions. Usually this is to create a range object.
+#
+# 1..2
+#
+# Sometimes this operator is used to create a flip-flop.
+#
+# if value == 5 .. value == 10
+# end
+#
+# One of the sides of the expression may be nil, but not both.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#4540
+class SyntaxTree::RangeNode < ::SyntaxTree::Node
+ # @return [RangeNode] a new instance of RangeNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4553
+ def initialize(left:, operator:, right:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4607
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4561
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4565
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4551
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4569
+ def copy(left: T.unsafe(nil), operator: T.unsafe(nil), right: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4565
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4584
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#4594
+ def format(q); end
+
+ # [nil | Node] the left side of the expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4542
+ def left; end
+
+ # [Op] the operator used for this range
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4545
+ def operator; end
+
+ # [nil | Node] the right side of the expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#4548
+ def right; end
+end
+
+# RationalLiteral represents the use of a rational number literal.
+#
+# 1r
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#8897
+class SyntaxTree::RationalLiteral < ::SyntaxTree::Node
+ # @return [RationalLiteral] a new instance of RationalLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8904
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8939
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8910
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8914
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8902
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8918
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8914
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8931
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#8935
+ def format(q); end
+
+ # [String] the rational number literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#8899
+ def value; end
+end
+
+# Redo represents the use of the +redo+ keyword.
+#
+# redo
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9020
+class SyntaxTree::Redo < ::SyntaxTree::Node
+ # @return [Redo] a new instance of Redo
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9024
+ def initialize(location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9054
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9029
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9033
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9022
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9037
+ def copy(location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9033
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9046
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9050
+ def format(q); end
+end
+
+# RegexpBeg represents the start of a regular expression literal.
+#
+# /.+/
+#
+# In the example above, RegexpBeg represents the first / token. Regular
+# expression literals can also be declared using the %r syntax, as in:
+#
+# %r{.+}
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9116
+class SyntaxTree::RegexpBeg < ::SyntaxTree::Node
+ # @return [RegexpBeg] a new instance of RegexpBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9120
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9146
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9125
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9129
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9133
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9129
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9142
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the regular expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9118
+ def value; end
+end
+
+# RegexpContent represents the body of a regular expression.
+#
+# /.+ #{pattern} .+/
+#
+# In the example above, a RegexpContent node represents everything contained
+# within the forward slashes.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9065
+class SyntaxTree::RegexpContent < ::SyntaxTree::Node
+ # @return [RegexpContent] a new instance of RegexpContent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9073
+ def initialize(beginning:, parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9101
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9079
+ def accept(visitor); end
+
+ # [String] the opening of the regular expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9067
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9083
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9087
+ def copy(beginning: T.unsafe(nil), parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9083
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9097
+ def deconstruct_keys(_keys); end
+
+ # [Array[ StringDVar | StringEmbExpr | TStringContent ]] the parts of the
+ # regular expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9071
+ def parts; end
+end
+
+# RegexpEnd represents the end of a regular expression literal.
+#
+# /.+/m
+#
+# In the example above, the RegexpEnd event represents the /m at the end of
+# the regular expression literal. You can also declare regular expression
+# literals using %r, as in:
+#
+# %r{.+}m
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9161
+class SyntaxTree::RegexpEnd < ::SyntaxTree::Node
+ # @return [RegexpEnd] a new instance of RegexpEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9165
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9191
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9170
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9174
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9178
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9174
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9187
+ def deconstruct_keys(_keys); end
+
+ # [String] the end of the regular expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9163
+ def value; end
+end
+
+# RegexpLiteral represents a regular expression literal.
+#
+# /.+/
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9200
+class SyntaxTree::RegexpLiteral < ::SyntaxTree::Node
+ # @return [RegexpLiteral] a new instance of RegexpLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9214
+ def initialize(beginning:, ending:, parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9296
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9222
+ def accept(visitor); end
+
+ # [String] the beginning of the regular expression literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9202
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9226
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9212
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9230
+ def copy(beginning: T.unsafe(nil), ending: T.unsafe(nil), parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9226
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9245
+ def deconstruct_keys(_keys); end
+
+ # [String] the ending of the regular expression literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9205
+ def ending; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9256
+ def format(q); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9302
+ def options; end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # regular expression literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9209
+ def parts; end
+
+ private
+
+ # If the first part of this regex is plain string content, we have a space
+ # or an =, and we're contained within a command or command_call node, then
+ # we want to use braces because otherwise we could end up with an ambiguous
+ # operator, e.g. foo / bar/ or foo /=bar/
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9318
+ def ambiguous?(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9308
+ def include?(pattern); end
+end
+
+# Rescue represents the use of the rescue keyword inside of a BodyStmt node.
+#
+# begin
+# rescue
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9408
+class SyntaxTree::Rescue < ::SyntaxTree::Node
+ # @return [Rescue] a new instance of Rescue
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9424
+ def initialize(keyword:, exception:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9520
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9455
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9433
+ def bind_end(end_char, end_column); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9459
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9422
+ def comments; end
+
+ # [nil | Rescue] the optional next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9419
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9463
+ def copy(keyword: T.unsafe(nil), exception: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9459
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9485
+ def deconstruct_keys(_keys); end
+
+ # [nil | RescueEx] the exceptions being rescued
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9413
+ def exception; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9496
+ def format(q); end
+
+ # [Kw] the rescue keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9410
+ def keyword; end
+
+ # [Statements] the expressions to evaluate when an error is rescued
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9416
+ def statements; end
+end
+
+# RescueEx represents the list of exceptions being rescued in a rescue clause.
+#
+# begin
+# rescue Exception => exception
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9333
+class SyntaxTree::RescueEx < ::SyntaxTree::Node
+ # @return [RescueEx] a new instance of RescueEx
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9344
+ def initialize(exceptions:, variable:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9396
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9351
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9355
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9342
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9359
+ def copy(exceptions: T.unsafe(nil), variable: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9355
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9373
+ def deconstruct_keys(_keys); end
+
+ # [nil | Node] the list of exceptions being rescued
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9335
+ def exceptions; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9382
+ def format(q); end
+
+ # [nil | Field | VarField] the expression being used to capture the raised
+ # exception
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9339
+ def variable; end
+end
+
+# RescueMod represents the use of the modifier form of a +rescue+ clause.
+#
+# expression rescue value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9531
+class SyntaxTree::RescueMod < ::SyntaxTree::Node
+ # @return [RescueMod] a new instance of RescueMod
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9541
+ def initialize(statement:, value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9597
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9548
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9552
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9539
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9556
+ def copy(statement: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9552
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9570
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9579
+ def format(q); end
+
+ # [Node] the expression to execute
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9533
+ def statement; end
+
+ # [Node] the value to use if the executed expression raises an error
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9536
+ def value; end
+end
+
+# RestParam represents defining a parameter in a method definition that
+# accepts all remaining positional parameters.
+#
+# def method(*rest) end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9608
+class SyntaxTree::RestParam < ::SyntaxTree::Node
+ # @return [RestParam] a new instance of RestParam
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9615
+ def initialize(name:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9651
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9621
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9625
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9613
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9629
+ def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9625
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9642
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9646
+ def format(q); end
+
+ # [nil | Ident] the name of the parameter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9610
+ def name; end
+end
+
+# Retry represents the use of the +retry+ keyword.
+#
+# retry
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9660
+class SyntaxTree::Retry < ::SyntaxTree::Node
+ # @return [Retry] a new instance of Retry
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9664
+ def initialize(location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9694
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9669
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9673
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9662
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9677
+ def copy(location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9673
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9686
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9690
+ def format(q); end
+end
+
+# Return represents using the +return+ keyword with arguments.
+#
+# return value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9703
+class SyntaxTree::ReturnNode < ::SyntaxTree::Node
+ # @return [ReturnNode] a new instance of ReturnNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9710
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9745
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9716
+ def accept(visitor); end
+
+ # [nil | Args] the arguments being passed to the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9705
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9720
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9708
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9724
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9720
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9737
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9741
+ def format(q); end
+end
+
+# SClass represents a block of statements that should be evaluated within the
+# context of the singleton class of an object. It's frequently used to define
+# singleton methods.
+#
+# class << self
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9793
+class SyntaxTree::SClass < ::SyntaxTree::Node
+ # @return [SClass] a new instance of SClass
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9803
+ def initialize(target:, bodystmt:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9854
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9810
+ def accept(visitor); end
+
+ # [BodyStmt] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9798
+ def bodystmt; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9814
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9801
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9818
+ def copy(target: T.unsafe(nil), bodystmt: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9814
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9832
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9841
+ def format(q); end
+
+ # [Node] the target of the singleton class to enter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9795
+ def target; end
+end
+
+# Provides an interface for searching for a pattern of nodes against a
+# subtree of an AST.
+#
+# source://syntax_tree//lib/syntax_tree/search.rb#6
+class SyntaxTree::Search
+ # @return [Search] a new instance of Search
+ #
+ # source://syntax_tree//lib/syntax_tree/search.rb#9
+ def initialize(pattern); end
+
+ # Returns the value of attribute pattern.
+ #
+ # source://syntax_tree//lib/syntax_tree/search.rb#7
+ def pattern; end
+
+ # source://syntax_tree//lib/syntax_tree/search.rb#13
+ def scan(root); end
+end
+
+# Everything that has a block of code inside of it has a list of statements.
+# Normally we would just track those as a node that has an array body, but we
+# have some special handling in order to handle empty statement lists. They
+# need to have the right location information, so all of the parent node of
+# stmts nodes will report back down the location information. We then
+# propagate that onto void_stmt nodes inside the stmts in order to make sure
+# all comments get printed appropriately.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#9867
+class SyntaxTree::Statements < ::SyntaxTree::Node
+ # @return [Statements] a new instance of Statements
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9874
+ def initialize(body:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10000
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9927
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9880
+ def bind(parser, start_char, start_column, end_char, end_column); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9909
+ def bind_end(end_char, end_column); end
+
+ # [Array[ Node ]] the list of expressions contained within this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9869
+ def body; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9931
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9872
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9935
+ def copy(body: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9931
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9948
+ def deconstruct_keys(_keys); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#9921
+ def empty?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#9952
+ def format(q); end
+
+ private
+
+ # As efficiently as possible, gather up all of the comments that have been
+ # found while this statements list was being parsed and add them into the
+ # body.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10009
+ def attach_comments(parser, start_char, end_char); end
+end
+
+# StringConcat represents concatenating two strings together using a backward
+# slash.
+#
+# "first" \
+# "second"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10124
+class SyntaxTree::StringConcat < ::SyntaxTree::Node
+ # @return [StringConcat] a new instance of StringConcat
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10135
+ def initialize(left:, right:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10179
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10142
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10146
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10133
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10150
+ def copy(left: T.unsafe(nil), right: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10146
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10164
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10168
+ def format(q); end
+
+ # [Heredoc | StringConcat | StringLiteral] the left side of the
+ # concatenation
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10127
+ def left; end
+
+ # [StringLiteral] the right side of the concatenation
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10130
+ def right; end
+end
+
+# StringContent represents the contents of a string-like value.
+#
+# "string"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10051
+class SyntaxTree::StringContent < ::SyntaxTree::Node
+ # @return [StringContent] a new instance of StringContent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10059
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10086
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10065
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10069
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10057
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10073
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10069
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10082
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10090
+ def format(q); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10054
+ def parts; end
+end
+
+# StringDVar represents shorthand interpolation of a variable into a string.
+# It allows you to take an instance variable, class variable, or global
+# variable and omit the braces when interpolating.
+#
+# "#@variable"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10190
+class SyntaxTree::StringDVar < ::SyntaxTree::Node
+ # @return [StringDVar] a new instance of StringDVar
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10197
+ def initialize(variable:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10234
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10203
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10207
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10195
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10211
+ def copy(variable: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10207
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10224
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10228
+ def format(q); end
+
+ # [Backref | VarRef] the variable being interpolated
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10192
+ def variable; end
+end
+
+# StringEmbExpr represents interpolated content. It can be contained within a
+# couple of different parent nodes, including regular expressions, strings,
+# and dynamic symbols.
+#
+# "string #{expression}"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10245
+class SyntaxTree::StringEmbExpr < ::SyntaxTree::Node
+ # @return [StringEmbExpr] a new instance of StringEmbExpr
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10252
+ def initialize(statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10309
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10258
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10262
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10250
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10266
+ def copy(statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10262
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10279
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10283
+ def format(q); end
+
+ # [Statements] the expressions to be interpolated
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10247
+ def statements; end
+end
+
+# StringLiteral represents a string literal.
+#
+# "string"
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10318
+class SyntaxTree::StringLiteral < ::SyntaxTree::Node
+ # @return [StringLiteral] a new instance of StringLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10329
+ def initialize(parts:, quote:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10403
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10336
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10340
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10327
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10344
+ def copy(parts: T.unsafe(nil), quote: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10340
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10358
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10362
+ def format(q); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # string literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10321
+ def parts; end
+
+ # [nil | String] which quote was used by the string literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10324
+ def quote; end
+end
+
+# Super represents using the +super+ keyword with arguments. It can optionally
+# use parentheses.
+#
+# super(value)
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10414
+class SyntaxTree::Super < ::SyntaxTree::Node
+ # @return [Super] a new instance of Super
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10421
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10465
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10427
+ def accept(visitor); end
+
+ # [ArgParen | Args] the arguments to the keyword
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10416
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10431
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10419
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10435
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10431
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10448
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10452
+ def format(q); end
+end
+
+# SymBeg represents the beginning of a symbol literal.
+#
+# :symbol
+#
+# SymBeg is also used for dynamic symbols, as in:
+#
+# :"symbol"
+#
+# Finally, SymBeg is also used for symbols using the %s syntax, as in:
+#
+# %s[symbol]
+#
+# The value of this node is a string. In most cases (as in the first example
+# above) it will contain just ":". In the case of dynamic symbols it will
+# contain ":'" or ":\"". In the case of %s symbols, it will contain the start
+# of the symbol including the %s and the delimiter.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10486
+class SyntaxTree::SymBeg < ::SyntaxTree::Node
+ # @return [SymBeg] a new instance of SymBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10490
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10516
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10495
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10499
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10503
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10499
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10512
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the symbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10488
+ def value; end
+end
+
+# SymbolContent represents symbol contents and is always the child of a
+# SymbolLiteral node.
+#
+# :symbol
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10526
+class SyntaxTree::SymbolContent < ::SyntaxTree::Node
+ # @return [SymbolContent] a new instance of SymbolContent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10531
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10557
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10536
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10540
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10544
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10540
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10553
+ def deconstruct_keys(_keys); end
+
+ # [Backtick | Const | CVar | GVar | Ident | IVar | Kw | Op] the value of the
+ # symbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10529
+ def value; end
+end
+
+# SymbolLiteral represents a symbol in the system with no interpolation
+# (as opposed to a DynaSymbol which has interpolation).
+#
+# :symbol
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10567
+class SyntaxTree::SymbolLiteral < ::SyntaxTree::Node
+ # @return [SymbolLiteral] a new instance of SymbolLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10575
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10612
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10581
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10585
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10573
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10589
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10585
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10602
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10606
+ def format(q); end
+
+ # [Backtick | Const | CVar | GVar | Ident | IVar | Kw | Op | TStringContent]
+ # the value of the symbol
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10570
+ def value; end
+end
+
+# Symbols represents a symbol array literal with interpolation.
+#
+# %I[one two three]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10621
+class SyntaxTree::Symbols < ::SyntaxTree::Node
+ # @return [Symbols] a new instance of Symbols
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10631
+ def initialize(beginning:, elements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10687
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10638
+ def accept(visitor); end
+
+ # [SymbolsBeg] the token that opens this array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10623
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10642
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10629
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10646
+ def copy(beginning: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10642
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10656
+ def deconstruct_keys(_keys); end
+
+ # [Array[ Word ]] the words in the symbol array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10626
+ def elements; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10665
+ def format(q); end
+end
+
+# SymbolsBeg represents the start of a symbol array literal with
+# interpolation.
+#
+# %I[one two three]
+#
+# In the snippet above, SymbolsBeg represents the "%I[" token. Note that these
+# kinds of arrays can start with a lot of different delimiter types
+# (e.g., %I| or %I<).
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10701
+class SyntaxTree::SymbolsBeg < ::SyntaxTree::Node
+ # @return [SymbolsBeg] a new instance of SymbolsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10705
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10731
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10710
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10714
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10718
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10714
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10727
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the symbol literal array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10703
+ def value; end
+end
+
+# TLamBeg represents the beginning of the body of a lambda literal using
+# braces.
+#
+# -> { value }
+#
+# In the example above the TLamBeg represents the +{+ operator.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10782
+class SyntaxTree::TLamBeg < ::SyntaxTree::Node
+ # @return [TLamBeg] a new instance of TLamBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10786
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10812
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10791
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10795
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10799
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10795
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10808
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the body of the lambda literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10784
+ def value; end
+end
+
+# TLambda represents the beginning of a lambda literal.
+#
+# -> { value }
+#
+# In the example above the TLambda represents the +->+ operator.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10741
+class SyntaxTree::TLambda < ::SyntaxTree::Node
+ # @return [TLambda] a new instance of TLambda
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10745
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10771
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10750
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10754
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10758
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10754
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10767
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the lambda literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10743
+ def value; end
+end
+
+# TStringBeg represents the beginning of a string literal.
+#
+# "string"
+#
+# In the example above, TStringBeg represents the first set of quotes. Strings
+# can also use single quotes. They can also be declared using the +%q+ and
+# +%Q+ syntax, as in:
+#
+# %q{string}
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10934
+class SyntaxTree::TStringBeg < ::SyntaxTree::Node
+ # @return [TStringBeg] a new instance of TStringBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10938
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10964
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10943
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10947
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10951
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10947
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10960
+ def deconstruct_keys(_keys); end
+
+ # [String] the beginning of the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10936
+ def value; end
+end
+
+# TStringContent represents plain characters inside of an entity that accepts
+# string content like a string, heredoc, command string, or regular
+# expression.
+#
+# "string"
+#
+# In the example above, TStringContent represents the +string+ token contained
+# within the string.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10977
+class SyntaxTree::TStringContent < ::SyntaxTree::Node
+ # @return [TStringContent] a new instance of TStringContent
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10984
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11023
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10994
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10998
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10982
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11002
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10998
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11015
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11019
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10990
+ def match?(pattern); end
+
+ # [String] the content of the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10979
+ def value; end
+end
+
+# TStringEnd represents the end of a string literal.
+#
+# "string"
+#
+# In the example above, TStringEnd represents the second set of quotes.
+# Strings can also use single quotes. They can also be declared using the +%q+
+# and +%Q+ syntax, as in:
+#
+# %q{string}
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11038
+class SyntaxTree::TStringEnd < ::SyntaxTree::Node
+ # @return [TStringEnd] a new instance of TStringEnd
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11042
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11068
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11047
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11051
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11055
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11051
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11064
+ def deconstruct_keys(_keys); end
+
+ # [String] the end of the string
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11040
+ def value; end
+end
+
+# In order for an `if` or `unless` expression to be shortened to a ternary,
+# there has to be one and only one consequent clause which is an Else. Both
+# the body of the main node and the body of the Else node must have only one
+# statement, and that statement must not be on the denied list of potential
+# statements.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#6254
+module SyntaxTree::Ternaryable
+ class << self
+ # source://syntax_tree//lib/syntax_tree/node.rb#6256
+ def call(q, node); end
+
+ private
+
+ # Certain expressions cannot be reduced to a ternary without adding
+ # parentheses around them. In this case we say they cannot be ternaried
+ # and default instead to breaking them into multiple lines.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#6294
+ def ternaryable?(statement); end
+ end
+end
+
+# TopConstField is always the child node of some kind of assignment. It
+# represents when you're assigning to a constant that is being referenced at
+# the top level.
+#
+# ::Constant = value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10823
+class SyntaxTree::TopConstField < ::SyntaxTree::Node
+ # @return [TopConstField] a new instance of TopConstField
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10830
+ def initialize(constant:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10866
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10836
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10840
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10828
+ def comments; end
+
+ # [Const] the constant being assigned
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10825
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10844
+ def copy(constant: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10840
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10857
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10861
+ def format(q); end
+end
+
+# TopConstRef is very similar to TopConstField except that it is not involved
+# in an assignment.
+#
+# ::Constant
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#10876
+class SyntaxTree::TopConstRef < ::SyntaxTree::Node
+ # @return [TopConstRef] a new instance of TopConstRef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10883
+ def initialize(constant:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10919
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10889
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10893
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10881
+ def comments; end
+
+ # [Const] the constant being referenced
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#10878
+ def constant; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10897
+ def copy(constant: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10893
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10910
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#10914
+ def format(q); end
+end
+
+# This module is responsible for translating the Syntax Tree syntax tree into
+# other representations.
+#
+# source://syntax_tree//lib/syntax_tree/translation.rb#6
+module SyntaxTree::Translation
+ class << self
+ # This method translates the given node into the representation defined by
+ # the whitequark/parser gem. We don't explicitly list it as a dependency
+ # because it's not required for the core functionality of Syntax Tree.
+ #
+ # source://syntax_tree//lib/syntax_tree/translation.rb#10
+ def to_parser(node, buffer); end
+
+ # This method translates the given node into the representation defined by
+ # the rubocop/rubocop-ast gem. We don't explicitly list it as a dependency
+ # because it's not required for the core functionality of Syntax Tree.
+ #
+ # source://syntax_tree//lib/syntax_tree/translation.rb#20
+ def to_rubocop_ast(node, buffer); end
+ end
+end
+
+# Unary represents a unary method being called on an expression, as in +!+ or
+# +~+.
+#
+# !value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11161
+class SyntaxTree::Unary < ::SyntaxTree::Node
+ # @return [Unary] a new instance of Unary
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11171
+ def initialize(operator:, statement:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11214
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11178
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11182
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11169
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11186
+ def copy(operator: T.unsafe(nil), statement: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11182
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11200
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11209
+ def format(q); end
+
+ # [String] the operator being used
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11163
+ def operator; end
+
+ # [Node] the statement on which to operate
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11166
+ def statement; end
+end
+
+# Undef represents the use of the +undef+ keyword.
+#
+# undef method
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11224
+class SyntaxTree::Undef < ::SyntaxTree::Node
+ # @return [Undef] a new instance of Undef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11255
+ def initialize(symbols:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11298
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11261
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11265
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11253
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11269
+ def copy(symbols: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11265
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11282
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11286
+ def format(q); end
+
+ # [Array[ DynaSymbol | SymbolLiteral ]] the symbols to undefine
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11250
+ def symbols; end
+end
+
+# Undef accepts a variable number of arguments that can be either DynaSymbol
+# or SymbolLiteral objects. For SymbolLiteral objects we descend directly
+# into the value in order to have it come out as bare words.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11228
+class SyntaxTree::Undef::UndefArgumentFormatter
+ # @return [UndefArgumentFormatter] a new instance of UndefArgumentFormatter
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11232
+ def initialize(node); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11236
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11244
+ def format(q); end
+
+ # [DynaSymbol | SymbolLiteral] the symbol to undefine
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11230
+ def node; end
+end
+
+# Unless represents the first clause in an +unless+ chain.
+#
+# unless predicate
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11308
+class SyntaxTree::UnlessNode < ::SyntaxTree::Node
+ # @return [UnlessNode] a new instance of UnlessNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11321
+ def initialize(predicate:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11366
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11329
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11333
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11319
+ def comments; end
+
+ # [nil | Elsif | Else] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11316
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11337
+ def copy(predicate: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11333
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11352
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11362
+ def format(q); end
+
+ # Checks if the node was originally found in the modifier form.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11372
+ def modifier?; end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11310
+ def predicate; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11313
+ def statements; end
+end
+
+# Until represents an +until+ loop.
+#
+# until predicate
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11454
+class SyntaxTree::UntilNode < ::SyntaxTree::Node
+ # @return [UntilNode] a new instance of UntilNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11464
+ def initialize(predicate:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11506
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11471
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11475
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11462
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11479
+ def copy(predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11475
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11493
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11502
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11511
+ def modifier?; end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11456
+ def predicate; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11459
+ def statements; end
+end
+
+# VCall represent any plain named object with Ruby that could be either a
+# local variable or a method call.
+#
+# variable
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11716
+class SyntaxTree::VCall < ::SyntaxTree::Node
+ # @return [VCall] a new instance of VCall
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11723
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11758
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11729
+ def accept(visitor); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11762
+ def access_control?; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11766
+ def arity; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11733
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11721
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11737
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11733
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11750
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11754
+ def format(q); end
+
+ # [Ident] the value of this expression
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11718
+ def value; end
+end
+
+# source://syntax_tree//lib/syntax_tree/version.rb#4
+SyntaxTree::VERSION = T.let(T.unsafe(nil), String)
+
+# VarField represents a variable that is being assigned a value. As such, it
+# is always a child of an assignment type node.
+#
+# variable = value
+#
+# In the example above, the VarField node represents the +variable+ token.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11522
+class SyntaxTree::VarField < ::SyntaxTree::Node
+ # @return [VarField] a new instance of VarField
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11529
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11568
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11535
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11539
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11527
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11543
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11539
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11556
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11560
+ def format(q); end
+
+ # [nil | :nil | Const | CVar | GVar | Ident | IVar] the target of this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11524
+ def value; end
+end
+
+# VarRef represents a variable reference.
+#
+# true
+#
+# This can be a plain local variable like the example above. It can also be a
+# constant, a class variable, a global variable, an instance variable, a
+# keyword (like +self+, +nil+, +true+, or +false+), or a numbered block
+# variable.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11581
+class SyntaxTree::VarRef < ::SyntaxTree::Node
+ # @return [VarRef] a new instance of VarRef
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11588
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11623
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11594
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11598
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11586
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11602
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11598
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11615
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11619
+ def format(q); end
+
+ # Oh man I hate this so much. Basically, ripper doesn't provide enough
+ # functionality to actually know where pins are within an expression. So we
+ # have to walk the tree ourselves and insert more information. In doing so,
+ # we have to replace this node by a pinned node when necessary.
+ #
+ # To be clear, this method should just not exist. It's not good. It's a
+ # place of shame. But it's necessary for now, so I'm keeping it.
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11634
+ def pin(parent, pin); end
+
+ # [Const | CVar | GVar | Ident | IVar | Kw] the value of this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11583
+ def value; end
+end
+
+# Visitor is a parent class that provides the ability to walk down the tree
+# and handle a subset of nodes. By defining your own subclass, you can
+# explicitly handle a node type by defining a visit_* method.
+#
+# source://syntax_tree//lib/syntax_tree/visitor.rb#7
+class SyntaxTree::Visitor < ::SyntaxTree::BasicVisitor
+ # Visit a BEGINBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_BEGIN(node); end
+
+ # Visit a CHAR node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_CHAR(node); end
+
+ # Visit an ENDBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_END(node); end
+
+ # Visit an EndContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit___end__(node); end
+
+ # Visit an AliasNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_alias(node); end
+
+ # Visit an ARef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_aref(node); end
+
+ # Visit an ARefField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_aref_field(node); end
+
+ # Visit an ArgBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_arg_block(node); end
+
+ # Visit an ArgParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_arg_paren(node); end
+
+ # Visit an ArgStar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_arg_star(node); end
+
+ # Visit an Args node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_args(node); end
+
+ # Visit an ArgsForward node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_args_forward(node); end
+
+ # Visit an ArrayLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_array(node); end
+
+ # Visit an AryPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_aryptn(node); end
+
+ # Visit an Assign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_assign(node); end
+
+ # Visit an Assoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_assoc(node); end
+
+ # Visit an AssocSplat node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_assoc_splat(node); end
+
+ # Visit a Backref node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_backref(node); end
+
+ # Visit a Backtick node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_backtick(node); end
+
+ # Visit a BareAssocHash node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_bare_assoc_hash(node); end
+
+ # Visit a Begin node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_begin(node); end
+
+ # Visit a Binary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_binary(node); end
+
+ # Visit a Block node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_block(node); end
+
+ # Visit a BlockVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_block_var(node); end
+
+ # Visit a BlockArg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_blockarg(node); end
+
+ # Visit a BodyStmt node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_bodystmt(node); end
+
+ # Visit a Break node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_break(node); end
+
+ # Visit a Call node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_call(node); end
+
+ # Visit a Case node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_case(node); end
+
+ # Visit a ClassDeclaration node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_class(node); end
+
+ # Visit a Comma node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_comma(node); end
+
+ # Visit a Command node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_command(node); end
+
+ # Visit a CommandCall node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_command_call(node); end
+
+ # Visit a Comment node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_comment(node); end
+
+ # Visit a Const node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_const(node); end
+
+ # Visit a ConstPathField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_const_path_field(node); end
+
+ # Visit a ConstPathRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_const_path_ref(node); end
+
+ # Visit a ConstRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_const_ref(node); end
+
+ # Visit a CVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_cvar(node); end
+
+ # Visit a Def node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_def(node); end
+
+ # Visit a Defined node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_defined(node); end
+
+ # Visit a DynaSymbol node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_dyna_symbol(node); end
+
+ # Visit an Else node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_else(node); end
+
+ # Visit an Elsif node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_elsif(node); end
+
+ # Visit an EmbDoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_embdoc(node); end
+
+ # Visit an EmbExprBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_embexpr_beg(node); end
+
+ # Visit an EmbExprEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_embexpr_end(node); end
+
+ # Visit an EmbVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_embvar(node); end
+
+ # Visit an Ensure node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_ensure(node); end
+
+ # Visit an ExcessedComma node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_excessed_comma(node); end
+
+ # Visit a Field node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_field(node); end
+
+ # Visit a FloatLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_float(node); end
+
+ # Visit a FndPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_fndptn(node); end
+
+ # Visit a For node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_for(node); end
+
+ # Visit a GVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_gvar(node); end
+
+ # Visit a HashLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_hash(node); end
+
+ # Visit a Heredoc node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_heredoc(node); end
+
+ # Visit a HeredocBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_heredoc_beg(node); end
+
+ # Visit a HeredocEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_heredoc_end(node); end
+
+ # Visit a HshPtn node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_hshptn(node); end
+
+ # Visit an Ident node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_ident(node); end
+
+ # Visit an IfNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_if(node); end
+
+ # Visit an IfOp node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_if_op(node); end
+
+ # Visit an Imaginary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_imaginary(node); end
+
+ # Visit an In node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_in(node); end
+
+ # Visit an Int node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_int(node); end
+
+ # Visit an IVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_ivar(node); end
+
+ # Visit a Kw node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_kw(node); end
+
+ # Visit a KwRestParam node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_kwrest_param(node); end
+
+ # Visit a Label node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_label(node); end
+
+ # Visit a LabelEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_label_end(node); end
+
+ # Visit a Lambda node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_lambda(node); end
+
+ # Visit a LambdaVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_lambda_var(node); end
+
+ # Visit a LBrace node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_lbrace(node); end
+
+ # Visit a LBracket node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_lbracket(node); end
+
+ # Visit a LParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_lparen(node); end
+
+ # Visit a MAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_massign(node); end
+
+ # Visit a MethodAddBlock node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_method_add_block(node); end
+
+ # Visit a MLHS node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_mlhs(node); end
+
+ # Visit a MLHSParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_mlhs_paren(node); end
+
+ # Visit a ModuleDeclaration node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_module(node); end
+
+ # Visit a MRHS node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_mrhs(node); end
+
+ # Visit a Next node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_next(node); end
+
+ # Visit a Not node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_not(node); end
+
+ # Visit an Op node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_op(node); end
+
+ # Visit an OpAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_opassign(node); end
+
+ # Visit a Params node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_params(node); end
+
+ # Visit a Paren node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_paren(node); end
+
+ # Visit a Period node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_period(node); end
+
+ # Visit a PinnedBegin node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_pinned_begin(node); end
+
+ # Visit a PinnedVarRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_pinned_var_ref(node); end
+
+ # Visit a Program node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_program(node); end
+
+ # Visit a QSymbols node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_qsymbols(node); end
+
+ # Visit a QSymbolsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_qsymbols_beg(node); end
+
+ # Visit a QWords node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_qwords(node); end
+
+ # Visit a QWordsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_qwords_beg(node); end
+
+ # Visit a RangeNode node
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_range(node); end
+
+ # Visit a RAssign node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rassign(node); end
+
+ # Visit a RationalLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rational(node); end
+
+ # Visit a RBrace node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rbrace(node); end
+
+ # Visit a RBracket node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rbracket(node); end
+
+ # Visit a Redo node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_redo(node); end
+
+ # Visit a RegexpBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_regexp_beg(node); end
+
+ # Visit a RegexpContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_regexp_content(node); end
+
+ # Visit a RegexpEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_regexp_end(node); end
+
+ # Visit a RegexpLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_regexp_literal(node); end
+
+ # Visit a Rescue node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rescue(node); end
+
+ # Visit a RescueEx node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rescue_ex(node); end
+
+ # Visit a RescueMod node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rescue_mod(node); end
+
+ # Visit a RestParam node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rest_param(node); end
+
+ # Visit a Retry node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_retry(node); end
+
+ # Visit a Return node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_return(node); end
+
+ # Visit a RParen node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_rparen(node); end
+
+ # Visit a SClass node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_sclass(node); end
+
+ # Visit a Statements node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_statements(node); end
+
+ # Visit a StringConcat node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_string_concat(node); end
+
+ # Visit a StringContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_string_content(node); end
+
+ # Visit a StringDVar node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_string_dvar(node); end
+
+ # Visit a StringEmbExpr node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_string_embexpr(node); end
+
+ # Visit a StringLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_string_literal(node); end
+
+ # Visit a Super node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_super(node); end
+
+ # Visit a SymBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_symbeg(node); end
+
+ # Visit a SymbolContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_symbol_content(node); end
+
+ # Visit a SymbolLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_symbol_literal(node); end
+
+ # Visit a Symbols node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_symbols(node); end
+
+ # Visit a SymbolsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_symbols_beg(node); end
+
+ # Visit a TLambda node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_tlambda(node); end
+
+ # Visit a TLamBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_tlambeg(node); end
+
+ # Visit a TopConstField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_top_const_field(node); end
+
+ # Visit a TopConstRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_top_const_ref(node); end
+
+ # Visit a TStringBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_tstring_beg(node); end
+
+ # Visit a TStringContent node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_tstring_content(node); end
+
+ # Visit a TStringEnd node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_tstring_end(node); end
+
+ # Visit an Unary node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_unary(node); end
+
+ # Visit an Undef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_undef(node); end
+
+ # Visit an UnlessNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_unless(node); end
+
+ # Visit an UntilNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_until(node); end
+
+ # Visit a VarField node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_var_field(node); end
+
+ # Visit a VarRef node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_var_ref(node); end
+
+ # Visit a VCall node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_vcall(node); end
+
+ # Visit a VoidStmt node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_void_stmt(node); end
+
+ # Visit a When node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_when(node); end
+
+ # Visit a WhileNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_while(node); end
+
+ # Visit a Word node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_word(node); end
+
+ # Visit a Words node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_words(node); end
+
+ # Visit a WordsBeg node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_words_beg(node); end
+
+ # Visit a XString node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_xstring(node); end
+
+ # Visit a XStringLiteral node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_xstring_literal(node); end
+
+ # Visit a YieldNode node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_yield(node); end
+
+ # Visit a ZSuper node.
+ #
+ # source://syntax_tree//lib/syntax_tree/basic_visitor.rb#113
+ def visit_zsuper(node); end
+end
+
+# VoidStmt represents an empty lexical block of code.
+#
+# ;;
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11775
+class SyntaxTree::VoidStmt < ::SyntaxTree::Node
+ # @return [VoidStmt] a new instance of VoidStmt
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11779
+ def initialize(location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11808
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11784
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11788
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11777
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11792
+ def copy(location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11788
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11801
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11805
+ def format(q); end
+end
+
+# When represents a +when+ clause in a +case+ chain.
+#
+# case value
+# when predicate
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11819
+class SyntaxTree::When < ::SyntaxTree::Node
+ # @return [When] a new instance of When
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11832
+ def initialize(arguments:, statements:, consequent:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11924
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11840
+ def accept(visitor); end
+
+ # [Args] the arguments to the when clause
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11821
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11844
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11830
+ def comments; end
+
+ # [nil | Else | When] the next clause in the chain
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11827
+ def consequent; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11848
+ def copy(arguments: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11844
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11863
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11889
+ def format(q); end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11824
+ def statements; end
+end
+
+# We're going to keep a single instance of this separator around so we don't
+# have to allocate a new one every time we format a when clause.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11887
+SyntaxTree::When::SEPARATOR = T.let(T.unsafe(nil), SyntaxTree::When::Separator)
+
+# We have a special separator here for when clauses which causes them to
+# fill as much of the line as possible as opposed to everything breaking
+# into its own line as soon as you hit the print limit.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11876
+class SyntaxTree::When::Separator
+ # source://syntax_tree//lib/syntax_tree/node.rb#11877
+ def call(q); end
+end
+
+# While represents a +while+ loop.
+#
+# while predicate
+# end
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#11935
+class SyntaxTree::WhileNode < ::SyntaxTree::Node
+ # @return [WhileNode] a new instance of WhileNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11945
+ def initialize(predicate:, statements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11987
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11952
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11956
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11943
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11960
+ def copy(predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11956
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11974
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#11983
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11992
+ def modifier?; end
+
+ # [Node] the expression to be checked
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11937
+ def predicate; end
+
+ # [Statements] the expressions to be executed
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#11940
+ def statements; end
+end
+
+# WithScope is a module intended to be included in classes inheriting from
+# Visitor. The module overrides a few visit methods to automatically keep
+# track of local variables and arguments defined in the current scope.
+# Example usage:
+#
+# class MyVisitor < Visitor
+# include WithScope
+#
+# def visit_ident(node)
+# # Check if we're visiting an identifier for an argument, a local
+# # variable or something else
+# local = current_scope.find_local(node)
+#
+# if local.type == :argument
+# # handle identifiers for arguments
+# elsif local.type == :variable
+# # handle identifiers for variables
+# else
+# # handle other identifiers, such as method names
+# end
+# end
+# end
+#
+# source://syntax_tree//lib/syntax_tree/with_scope.rb#27
+module SyntaxTree::WithScope
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#122
+ def initialize(*args, **kwargs, &block); end
+
+ # Returns the value of attribute current_scope.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#120
+ def current_scope; end
+
+ # Visit for capturing local variables defined in regex named capture groups
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#236
+ def visit_binary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#189
+ def visit_block_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#182
+ def visit_blockarg(node); end
+
+ # Visits for nodes that create new scopes, such as classes, modules
+ # and method definitions.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#131
+ def visit_class(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#147
+ def visit_def(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#175
+ def visit_kwrest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#189
+ def visit_lambda_var(node); end
+
+ # When we find a method invocation with a block, only the code that happens
+ # inside of the block needs a fresh scope. The method invocation
+ # itself happens in the same scope.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#142
+ def visit_method_add_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#135
+ def visit_module(node); end
+
+ # Visit for keeping track of local arguments, such as method and block
+ # arguments.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#153
+ def visit_params(node); end
+
+ # Visit for keeping track of local variable definitions
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#207
+ def visit_pinned_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#168
+ def visit_rest_param(node); end
+
+ # Visit for keeping track of local variable definitions
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#199
+ def visit_var_field(node); end
+
+ # Visits for keeping track of variable and argument usages
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#215
+ def visit_var_ref(node); end
+
+ # When using regex named capture groups, vcalls might actually be a variable
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#227
+ def visit_vcall(node); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#285
+ def add_argument_definitions(list); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#299
+ def next_scope_id; end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#303
+ def with_scope(parent_scope = T.unsafe(nil)); end
+end
+
+# The scope class is used to keep track of local variables and arguments
+# inside a particular scope.
+#
+# source://syntax_tree//lib/syntax_tree/with_scope.rb#30
+class SyntaxTree::WithScope::Scope
+ # @return [Scope] a new instance of Scope
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#68
+ def initialize(id, parent = T.unsafe(nil)); end
+
+ # Adding a local definition will either insert a new entry in the locals
+ # hash or append a new definition location to an existing local. Notice
+ # that it's not possible to change the type of a local after it has been
+ # registered.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#78
+ def add_local_definition(identifier, type); end
+
+ # Adding a local usage will either insert a new entry in the locals
+ # hash or append a new usage location to an existing local. Notice that
+ # it's not possible to change the type of a local after it has been
+ # registered.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#95
+ def add_local_usage(identifier, type); end
+
+ # Try to find the local given its name in this scope or any of its
+ # parents.
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#102
+ def find_local(name); end
+
+ # [Integer] a unique identifier for this scope
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#59
+ def id; end
+
+ # [Hash[String, Local]] The local variables and arguments defined in this
+ # scope
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#66
+ def locals; end
+
+ # [scope | nil] The parent scope
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#62
+ def parent; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#108
+ def resolve_local(name, type); end
+end
+
+# This class tracks the occurrences of a local variable or argument.
+#
+# source://syntax_tree//lib/syntax_tree/with_scope.rb#32
+class SyntaxTree::WithScope::Scope::Local
+ # @return [Local] a new instance of Local
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#43
+ def initialize(type); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#49
+ def add_definition(location); end
+
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#53
+ def add_usage(location); end
+
+ # [Array[Location]] The locations of all definitions and assignments of
+ # this local
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#38
+ def definitions; end
+
+ # [Symbol] The type of the local (e.g. :argument, :variable)
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#34
+ def type; end
+
+ # [Array[Location]] The locations of all usages of this local
+ #
+ # source://syntax_tree//lib/syntax_tree/with_scope.rb#41
+ def usages; end
+end
+
+# Word represents an element within a special array literal that accepts
+# interpolation.
+#
+# %W[a#{b}c xyz]
+#
+# In the example above, there would be two Word nodes within a parent Words
+# node.
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12004
+class SyntaxTree::Word < ::SyntaxTree::Node
+ # @return [Word] a new instance of Word
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12012
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12051
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12022
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12026
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12010
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12030
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12026
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12043
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12047
+ def format(q); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12018
+ def match?(pattern); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # word
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12007
+ def parts; end
+end
+
+# Words represents a string literal array with interpolation.
+#
+# %W[one two three]
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12060
+class SyntaxTree::Words < ::SyntaxTree::Node
+ # @return [Words] a new instance of Words
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12070
+ def initialize(beginning:, elements:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12126
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12077
+ def accept(visitor); end
+
+ # [WordsBeg] the token that opens this array literal
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12062
+ def beginning; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12081
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12068
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12085
+ def copy(beginning: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12081
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12095
+ def deconstruct_keys(_keys); end
+
+ # [Array[ Word ]] the elements of this array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12065
+ def elements; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12104
+ def format(q); end
+end
+
+# WordsBeg represents the beginning of a string literal array with
+# interpolation.
+#
+# %W[one two three]
+#
+# In the snippet above, a WordsBeg would be created with the value of "%W[".
+# Note that these kinds of arrays can start with a lot of different delimiter
+# types (e.g., %W| or %W<).
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12140
+class SyntaxTree::WordsBeg < ::SyntaxTree::Node
+ # @return [WordsBeg] a new instance of WordsBeg
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12144
+ def initialize(value:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12170
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12149
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12153
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12157
+ def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12153
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12166
+ def deconstruct_keys(_keys); end
+
+ # [String] the start of the word literal array
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12142
+ def value; end
+end
+
+# XString represents the contents of an XStringLiteral.
+#
+# `ls`
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12179
+class SyntaxTree::XString < ::SyntaxTree::Node
+ # @return [XString] a new instance of XString
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12184
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12210
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12189
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12193
+ def child_nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12197
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12193
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12206
+ def deconstruct_keys(_keys); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # xstring
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12182
+ def parts; end
+end
+
+# XStringLiteral represents a string that gets executed.
+#
+# `ls`
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12219
+class SyntaxTree::XStringLiteral < ::SyntaxTree::Node
+ # @return [XStringLiteral] a new instance of XStringLiteral
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12227
+ def initialize(parts:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12264
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12233
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12237
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12225
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12241
+ def copy(parts: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12237
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12254
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12258
+ def format(q); end
+
+ # [Array[ StringEmbExpr | StringDVar | TStringContent ]] the parts of the
+ # xstring
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12222
+ def parts; end
+end
+
+# This module provides an object representation of the YARV bytecode.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#4
+module SyntaxTree::YARV
+ class << self
+ # A convenience method for creating a CallData object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#88
+ def calldata(method, argc = T.unsafe(nil), flags = T.unsafe(nil), kw_arg = T.unsafe(nil)); end
+
+ # Compile the given source into a YARV instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv.rb#25
+ def compile(source, options = T.unsafe(nil)); end
+
+ # Compile and interpret the given source.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv.rb#30
+ def interpret(source, options = T.unsafe(nil)); end
+ end
+end
+
+# ### Summary
+#
+# `adjuststack` accepts a single integer argument and removes that many
+# elements from the top of the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = [true]
+# x[0] ||= nil
+# x[0]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#69
+class SyntaxTree::YARV::AdjustStack < ::SyntaxTree::YARV::Instruction
+ # @return [AdjustStack] a new instance of AdjustStack
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#72
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#88
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#100
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#84
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#76
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#92
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#70
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#96
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#80
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `anytostring` ensures that the value on top of the stack is a string.
+#
+# It pops two values off the stack. If the first value is a string it
+# pushes it back on the stack. If the first value is not a string, it uses
+# Ruby's built in string coercion to coerce the second value to a string
+# and then pushes that back on the stack.
+#
+# This is used in conjunction with `objtostring` as a fallback for when an
+# object's `to_s` method does not return a string.
+#
+# ### Usage
+#
+# ~~~ruby
+# "#{5}"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#123
+class SyntaxTree::YARV::AnyToString < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#136
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#148
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#132
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#124
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#140
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#144
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#128
+ def to_a(_iseq); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#5
+class SyntaxTree::YARV::Assembler
+ # @return [Assembler] a new instance of Assembler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#66
+ def initialize(lines); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#70
+ def assemble; end
+
+ # Returns the value of attribute lines.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#64
+ def lines; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#88
+ def assemble_iseq(iseq, lines); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#408
+ def find_local(iseq, operands); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#417
+ def parse(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#449
+ def parse_calldata(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#444
+ def parse_nested(lines); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#432
+ def parse_number(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#424
+ def parse_options(value, options); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#436
+ def parse_string(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#440
+ def parse_symbol(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#428
+ def parse_type(value, type); end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#78
+ def assemble(source); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#82
+ def assemble_file(filepath); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#28
+SyntaxTree::YARV::Assembler::CALLDATA_FLAGS = T.let(T.unsafe(nil), Hash)
+
+# source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#43
+SyntaxTree::YARV::Assembler::DEFINED_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#6
+class SyntaxTree::YARV::Assembler::ObjectVisitor < ::SyntaxTree::YARV::Compiler::RubyVisitor
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#7
+ def visit_dyna_symbol(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/assembler.rb#15
+ def visit_string_literal(node); end
+end
+
+# This object represents a single basic block, wherein all contained
+# instructions do not branch except for the last one.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#7
+class SyntaxTree::YARV::BasicBlock
+ # @return [BasicBlock] a new instance of BasicBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#23
+ def initialize(block_start, insns); end
+
+ # This is the index into the list of instructions where this block starts.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#12
+ def block_start; end
+
+ # Yield each instruction in this basic block along with its index from the
+ # original instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#35
+ def each_with_length; end
+
+ # This is the unique identifier for this basic block.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#9
+ def id; end
+
+ # This is an array of basic blocks that lead into this block.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#18
+ def incoming_blocks; end
+
+ # This is the set of instructions that this block contains.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#15
+ def insns; end
+
+ # This is an array of basic blocks that this block leads into.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#21
+ def outgoing_blocks; end
+
+ # This method is used to verify that the basic block is well formed. It
+ # checks that the only instruction in this basic block that branches is
+ # the last instruction.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/basic_block.rb#48
+ def verify; end
+end
+
+# Parses the given source code into a syntax tree, compiles that syntax tree
+# into YARV bytecode.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/bf.rb#7
+class SyntaxTree::YARV::Bf
+ # @return [Bf] a new instance of Bf
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#10
+ def initialize(source); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#14
+ def compile; end
+
+ # Returns the value of attribute source.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#8
+ def source; end
+
+ private
+
+ # $tape[$cursor] += value
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#84
+ def change_by(iseq, value); end
+
+ # $tape[$cursor] = $stdin.getc.ord
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#133
+ def input_char(iseq); end
+
+ # Jump back to the start of the loop.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#163
+ def loop_end(iseq, start_label, end_label); end
+
+ # unless $tape[$cursor] == 0
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#146
+ def loop_start(iseq); end
+
+ # $stdout.putc($tape[$cursor].chr)
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#120
+ def output_char(iseq); end
+
+ # $cursor += value
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/bf.rb#105
+ def shift_by(iseq, value); end
+end
+
+# ### Summary
+#
+# `branchif` has one argument: the jump index. It pops one value off the
+# stack: the jump condition.
+#
+# If the value popped off the stack is true, `branchif` jumps to
+# the jump index and continues executing there.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = true
+# x ||= "foo"
+# puts x
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#175
+class SyntaxTree::YARV::BranchIf < ::SyntaxTree::YARV::Instruction
+ # @return [BranchIf] a new instance of BranchIf
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#178
+ def initialize(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#194
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#210
+ def branch_targets; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#206
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#190
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#182
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#214
+ def falls_through?; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#176
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#198
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#202
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#186
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `branchnil` has one argument: the jump index. It pops one value off the
+# stack: the jump condition.
+#
+# If the value popped off the stack is nil, `branchnil` jumps to
+# the jump index and continues executing there.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = nil
+# if x&.to_s
+# puts "hi"
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#236
+class SyntaxTree::YARV::BranchNil < ::SyntaxTree::YARV::Instruction
+ # @return [BranchNil] a new instance of BranchNil
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#239
+ def initialize(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#255
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#271
+ def branch_targets; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#267
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#251
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#243
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#275
+ def falls_through?; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#237
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#259
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#263
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#247
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `branchunless` has one argument: the jump index. It pops one value off
+# the stack: the jump condition.
+#
+# If the value popped off the stack is false or nil, `branchunless` jumps
+# to the jump index and continues executing there.
+#
+# ### Usage
+#
+# ~~~ruby
+# if 2 + 3
+# puts "foo"
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#296
+class SyntaxTree::YARV::BranchUnless < ::SyntaxTree::YARV::Instruction
+ # @return [BranchUnless] a new instance of BranchUnless
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#299
+ def initialize(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#315
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#331
+ def branch_targets; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#327
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#311
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#303
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#335
+ def falls_through?; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#297
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#319
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#323
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#307
+ def to_a(_iseq); end
+end
+
+# This is an operand to various YARV instructions that represents the
+# information about a specific call site.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#7
+class SyntaxTree::YARV::CallData
+ # @return [CallData] a new instance of CallData
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#31
+ def initialize(method, argc = T.unsafe(nil), flags = T.unsafe(nil), kw_arg = T.unsafe(nil)); end
+
+ # Returns the value of attribute argc.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#29
+ def argc; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#43
+ def flag?(mask); end
+
+ # Returns the value of attribute flags.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#29
+ def flags; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#53
+ def inspect; end
+
+ # Returns the value of attribute kw_arg.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#29
+ def kw_arg; end
+
+ # Returns the value of attribute method.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#29
+ def method; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#47
+ def to_h; end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#77
+ def from(serialized); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_ARGS_BLOCKARG = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_ARGS_SIMPLE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_ARGS_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_BLOCKISEQ = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_FCALL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_KWARG = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_KW_SPLAT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_KW_SPLAT_MUT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_OPT_SEND = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_SUPER = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_TAILCALL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_VCALL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/calldata.rb#27
+SyntaxTree::YARV::CallData::CALL_ZSUPER = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `checkkeyword` checks if a keyword was passed at the callsite that
+# called into the method represented by the instruction sequence. It has
+# two arguments: the index of the local variable that stores the keywords
+# metadata and the index of the keyword within that metadata. It pushes
+# a boolean onto the stack indicating whether or not the keyword was
+# given.
+#
+# ### Usage
+#
+# ~~~ruby
+# def evaluate(value: rand)
+# value
+# end
+#
+# evaluate(value: 3)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#359
+class SyntaxTree::YARV::CheckKeyword < ::SyntaxTree::YARV::Instruction
+ # @return [CheckKeyword] a new instance of CheckKeyword
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#362
+ def initialize(keyword_bits_index, keyword_index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#386
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#400
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#382
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#367
+ def disasm(fmt); end
+
+ # Returns the value of attribute keyword_bits_index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#360
+ def keyword_bits_index; end
+
+ # Returns the value of attribute keyword_index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#360
+ def keyword_index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#392
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#396
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#374
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `checkmatch` checks if the current pattern matches the current value. It
+# pops the target and the pattern off the stack and pushes a boolean onto
+# the stack if it matches or not.
+#
+# ### Usage
+#
+# ~~~ruby
+# foo in Foo
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#417
+class SyntaxTree::YARV::CheckMatch < ::SyntaxTree::YARV::Instruction
+ # @return [CheckMatch] a new instance of CheckMatch
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#426
+ def initialize(type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#442
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#458
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#438
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#430
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#446
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#450
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#454
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#434
+ def to_a(_iseq); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#424
+ def type; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#472
+ def check?(pattern, target); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#422
+SyntaxTree::YARV::CheckMatch::VM_CHECKMATCH_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#419
+SyntaxTree::YARV::CheckMatch::VM_CHECKMATCH_TYPE_CASE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#421
+SyntaxTree::YARV::CheckMatch::VM_CHECKMATCH_TYPE_MASK = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#420
+SyntaxTree::YARV::CheckMatch::VM_CHECKMATCH_TYPE_RESCUE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#418
+SyntaxTree::YARV::CheckMatch::VM_CHECKMATCH_TYPE_WHEN = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `checktype` checks if the value on top of the stack is of a certain type.
+# The type is the only argument. It pops the value off the stack and pushes
+# a boolean onto the stack indicating whether or not the value is of the
+# given type.
+#
+# ### Usage
+#
+# ~~~ruby
+# foo in [bar]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#501
+class SyntaxTree::YARV::CheckType < ::SyntaxTree::YARV::Instruction
+ # @return [CheckType] a new instance of CheckType
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#526
+ def initialize(type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#588
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#608
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#584
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#530
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#592
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#596
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#600
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#580
+ def to_a(_iseq); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#524
+ def type; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#508
+SyntaxTree::YARV::CheckType::TYPE_ARRAY = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#511
+SyntaxTree::YARV::CheckType::TYPE_BIGNUM = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#503
+SyntaxTree::YARV::CheckType::TYPE_CLASS = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#515
+SyntaxTree::YARV::CheckType::TYPE_COMPLEX = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#513
+SyntaxTree::YARV::CheckType::TYPE_DATA = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#519
+SyntaxTree::YARV::CheckType::TYPE_FALSE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#512
+SyntaxTree::YARV::CheckType::TYPE_FILE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#521
+SyntaxTree::YARV::CheckType::TYPE_FIXNUM = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#505
+SyntaxTree::YARV::CheckType::TYPE_FLOAT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#509
+SyntaxTree::YARV::CheckType::TYPE_HASH = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#514
+SyntaxTree::YARV::CheckType::TYPE_MATCH = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#504
+SyntaxTree::YARV::CheckType::TYPE_MODULE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#517
+SyntaxTree::YARV::CheckType::TYPE_NIL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#502
+SyntaxTree::YARV::CheckType::TYPE_OBJECT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#516
+SyntaxTree::YARV::CheckType::TYPE_RATIONAL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#507
+SyntaxTree::YARV::CheckType::TYPE_REGEXP = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#506
+SyntaxTree::YARV::CheckType::TYPE_STRING = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#510
+SyntaxTree::YARV::CheckType::TYPE_STRUCT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#520
+SyntaxTree::YARV::CheckType::TYPE_SYMBOL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#518
+SyntaxTree::YARV::CheckType::TYPE_TRUE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#522
+SyntaxTree::YARV::CheckType::TYPE_UNDEF = T.let(T.unsafe(nil), Integer)
+
+# This class is an experiment in transforming Syntax Tree nodes into their
+# corresponding YARV instruction sequences. It attempts to mirror the
+# behavior of RubyVM::InstructionSequence.compile.
+#
+# You use this as with any other visitor. First you parse code into a tree,
+# then you visit it with this compiler. Visiting the root node of the tree
+# will return a SyntaxTree::YARV::Compiler::InstructionSequence object.
+# With that object you can call #to_a on it, which will return a serialized
+# form of the instruction sequence as an array. This array _should_ mirror
+# the array given by RubyVM::InstructionSequence#to_a.
+#
+# As an example, here is how you would compile a single expression:
+#
+# program = SyntaxTree.parse("1 + 2")
+# program.accept(SyntaxTree::YARV::Compiler.new).to_a
+#
+# [
+# "YARVInstructionSequence/SimpleDataFormat",
+# 3,
+# 1,
+# 1,
+# {:arg_size=>0, :local_size=>0, :stack_max=>2},
+# "",
+# "",
+# "",
+# 1,
+# :top,
+# [],
+# {},
+# [],
+# [
+# [:putobject_INT2FIX_1_],
+# [:putobject, 2],
+# [:opt_plus, {:mid=>:+, :flag=>16, :orig_argc=>1}],
+# [:leave]
+# ]
+# ]
+#
+# Note that this is the same output as calling:
+#
+# RubyVM::InstructionSequence.compile("1 + 2").to_a
+#
+# source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#47
+class SyntaxTree::YARV::Compiler < ::SyntaxTree::BasicVisitor
+ # @return [Compiler] a new instance of Compiler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#293
+ def initialize(options = T.unsafe(nil)); end
+
+ # The current instruction sequence that is being compiled.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#286
+ def iseq; end
+
+ # A boolean to track if we're currently compiling the last statement
+ # within a set of statements. This information is necessary to determine
+ # if we need to return the value of the last statement.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#291
+ def last_statement; end
+
+ # These options mirror the compilation options that we currently support
+ # that can be also passed to RubyVM::InstructionSequence.compile.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#283
+ def options; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#299
+ def visit_BEGIN(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#303
+ def visit_CHAR(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#311
+ def visit_END(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#339
+ def visit_alias(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#347
+ def visit_aref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#369
+ def visit_arg_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#373
+ def visit_arg_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#377
+ def visit_arg_star(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#382
+ def visit_args(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#386
+ def visit_array(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#421
+ def visit_aryptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#424
+ def visit_assign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#522
+ def visit_assoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#527
+ def visit_assoc_splat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#531
+ def visit_backref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#535
+ def visit_bare_assoc_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#543
+ def visit_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#546
+ def visit_binary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#575
+ def visit_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#585
+ def visit_block_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#599
+ def visit_blockarg(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#605
+ def visit_bodystmt(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#609
+ def visit_break(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#612
+ def visit_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#712
+ def visit_case(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#757
+ def visit_class(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#792
+ def visit_command(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#805
+ def visit_command_call(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#818
+ def visit_const_path_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#822
+ def visit_const_path_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#827
+ def visit_def(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#850
+ def visit_defined(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#907
+ def visit_dyna_symbol(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#913
+ def visit_else(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#918
+ def visit_elsif(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#929
+ def visit_ensure(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#932
+ def visit_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#936
+ def visit_float(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#940
+ def visit_fndptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#943
+ def visit_for(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#976
+ def visit_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#988
+ def visit_heredoc(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#985
+ def visit_hshptn(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#999
+ def visit_if(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1053
+ def visit_if_op(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1074
+ def visit_imaginary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1078
+ def visit_int(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1082
+ def visit_kwrest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1088
+ def visit_label(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1092
+ def visit_lambda(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1106
+ def visit_lambda_var(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1110
+ def visit_massign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1116
+ def visit_method_add_block(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1129
+ def visit_mlhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1142
+ def visit_module(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1171
+ def visit_mrhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1180
+ def visit_next(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1183
+ def visit_not(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1188
+ def visit_opassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1254
+ def visit_params(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1360
+ def visit_paren(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1364
+ def visit_pinned_begin(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1367
+ def visit_pinned_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1370
+ def visit_program(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1421
+ def visit_qsymbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1425
+ def visit_qwords(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1434
+ def visit_range(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1444
+ def visit_rassign(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1521
+ def visit_rational(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1525
+ def visit_redo(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1528
+ def visit_regexp_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1538
+ def visit_rescue(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1541
+ def visit_rescue_ex(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1544
+ def visit_rescue_mod(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1547
+ def visit_rest_param(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1553
+ def visit_retry(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1556
+ def visit_return(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1559
+ def visit_sclass(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1580
+ def visit_statements(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1594
+ def visit_string_concat(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1606
+ def visit_string_embexpr(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1610
+ def visit_string_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1619
+ def visit_super(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1633
+ def visit_symbol_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1637
+ def visit_symbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1656
+ def visit_top_const_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1660
+ def visit_tstring_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1668
+ def visit_unary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1689
+ def visit_undef(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1699
+ def visit_unless(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1725
+ def visit_until(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1744
+ def visit_var_field(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1761
+ def visit_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1796
+ def visit_vcall(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1808
+ def visit_when(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1812
+ def visit_while(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1831
+ def visit_word(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1840
+ def visit_words(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1850
+ def visit_xstring_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1863
+ def visit_yield(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1869
+ def visit_zsuper(_node); end
+
+ private
+
+ # This is a helper that is used in places where arguments may be present
+ # or they may be wrapped in parentheses. It's meant to descend down the
+ # tree and return an array of argument nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1887
+ def argument_parts(node); end
+
+ # Constant names when they are being assigned or referenced come in as a
+ # tree, but it's more convenient to work with them as an array. This
+ # method converts them into that array. This is nice because it's the
+ # operand that goes to opt_getconstant_path in Ruby 3.2.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1908
+ def constant_names(node); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2196
+ def last_statement?; end
+
+ # For the most part when an OpAssign (operator assignment) node with a ||=
+ # operator is being compiled it's a matter of reading the target, checking
+ # if the value should be evaluated, evaluating it if so, and then writing
+ # the result back to the target.
+ #
+ # However, in certain kinds of assignments (X, ::X, X::Y, @@x, and $x) we
+ # first check if the value is defined using the defined instruction. I
+ # don't know why it is necessary, and suspect that it isn't.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#1936
+ def opassign_defined(node); end
+
+ # Whenever a value is interpolated into a string-like structure, these
+ # three instructions are pushed.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2016
+ def push_interpolate; end
+
+ # Visit a type of pattern in a pattern match.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2029
+ def visit_pattern(node, end_label); end
+
+ # There are a lot of nodes in the AST that act as contains of parts of
+ # strings. This includes things like string literals, regular expressions,
+ # heredocs, etc. This method will visit all the parts of a string within
+ # those containers.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2137
+ def visit_string_parts(node); end
+
+ # The current instruction sequence that we're compiling is always stored
+ # on the compiler. When we descend into a node that has its own
+ # instruction sequence, this method can be called to temporarily set the
+ # new value of the instruction sequence, yield, and then set it back.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2167
+ def with_child_iseq(child_iseq); end
+
+ # When we're compiling the last statement of a set of statements within a
+ # scope, the instructions sometimes change from pops to leaves. These
+ # kinds of peephole optimizations can reduce the overall number of
+ # instructions. Therefore, we keep track of whether we're compiling the
+ # last statement of a scope and allow visit methods to query that
+ # information.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2185
+ def with_last_statement; end
+
+ # OpAssign nodes can have a number of different kinds of nodes as their
+ # "target" (i.e., the left-hand side of the assignment). When compiling
+ # these nodes we typically need to first fetch the current value of the
+ # variable, then perform some kind of action, then store the result back
+ # into the variable. This method handles that by first fetching the value,
+ # then yielding to the block, then storing the result.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#2206
+ def with_opassign(node); end
+end
+
+# This represents a set of options that can be passed to the compiler to
+# control how it compiles the code. It mirrors the options that can be
+# passed to RubyVM::InstructionSequence.compile, except it only includes
+# options that actually change the behavior.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#52
+class SyntaxTree::YARV::Compiler::Options
+ # @return [Options] a new instance of Options
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#53
+ def initialize(frozen_string_literal: T.unsafe(nil), inline_const_cache: T.unsafe(nil), operands_unification: T.unsafe(nil), peephole_optimization: T.unsafe(nil), specialized_instruction: T.unsafe(nil), tailcall_optimization: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#80
+ def frozen_string_literal!; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#84
+ def frozen_string_literal?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#88
+ def inline_const_cache?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#92
+ def operands_unification?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#96
+ def peephole_optimization?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#100
+ def specialized_instruction?; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#104
+ def tailcall_optimization?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#69
+ def to_hash; end
+end
+
+# This visitor is responsible for converting Syntax Tree nodes into their
+# corresponding Ruby structures. This is used to convert the operands of
+# some instructions like putobject that push a Ruby object directly onto
+# the stack. It is only used when the entire structure can be represented
+# at compile-time, as opposed to constructed at run-time.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#114
+class SyntaxTree::YARV::Compiler::RubyVisitor < ::SyntaxTree::BasicVisitor
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_BEGIN(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_CHAR(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_END(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit___end__(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_alias(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_aref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_aref_field(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_arg_block(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_arg_paren(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_arg_star(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_args(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_args_forward(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#128
+ def visit_array(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_aryptn(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_assign(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_assoc(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_assoc_splat(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_backref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_backtick(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#132
+ def visit_bare_assoc_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_begin(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_binary(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_block(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_block_var(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_blockarg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_bodystmt(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_break(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_call(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_case(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_class(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_comma(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_command(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_command_call(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_comment(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_const(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_const_path_field(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_const_path_ref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_const_ref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_cvar(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_def(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_defined(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_dyna_symbol(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_else(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_elsif(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_embdoc(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_embexpr_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_embexpr_end(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_embvar(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_ensure(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_excessed_comma(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_field(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#141
+ def visit_float(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_fndptn(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_for(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_gvar(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#132
+ def visit_hash(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_heredoc(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_heredoc_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_heredoc_end(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_hshptn(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_ident(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_if(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_if_op(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#147
+ def visit_imaginary(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_in(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#151
+ def visit_int(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_ivar(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_kw(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_kwrest_param(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#166
+ def visit_label(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_label_end(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_lambda(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_lambda_var(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_lbrace(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_lbracket(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_lparen(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_massign(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_method_add_block(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_mlhs(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_mlhs_paren(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_module(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#170
+ def visit_mrhs(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_next(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_not(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_op(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_opassign(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_params(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_paren(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_period(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_pinned_begin(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_pinned_var_ref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_program(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#174
+ def visit_qsymbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_qsymbols_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#178
+ def visit_qwords(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_qwords_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#182
+ def visit_range(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rassign(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#187
+ def visit_rational(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rbrace(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rbracket(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_redo(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_regexp_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_regexp_content(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_regexp_end(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#191
+ def visit_regexp_literal(node); end
+
+ # This isn't actually a visit method, though maybe it should be. It is
+ # responsible for converting the set of string options on a regular
+ # expression into its equivalent integer.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#249
+ def visit_regexp_literal_flags(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rescue(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rescue_ex(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rescue_mod(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rest_param(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_retry(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_return(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_rparen(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_sclass(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_statements(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_string_concat(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_string_content(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_string_dvar(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_string_embexpr(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_string_literal(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_super(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_symbeg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_symbol_content(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#204
+ def visit_symbol_literal(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#208
+ def visit_symbols(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_symbols_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_tlambda(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_tlambeg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_top_const_field(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_top_const_ref(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_tstring_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#212
+ def visit_tstring_content(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_tstring_end(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_unary(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_undef(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_unless(_node); end
+
+ # @raise [CompilationError]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_unsupported(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_until(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_var_field(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#216
+ def visit_var_ref(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_vcall(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_void_stmt(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_when(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_while(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#231
+ def visit_word(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#241
+ def visit_words(node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_words_beg(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_xstring(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_xstring_literal(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_yield(_node); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#268
+ def visit_zsuper(_node); end
+
+ class << self
+ # This will attempt to compile the given node. If it's possible, then
+ # it will return the compiled object. Otherwise it will return nil.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#122
+ def compile(node); end
+ end
+end
+
+# This error is raised whenever a node cannot be converted into a Ruby
+# object at compile-time.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/compiler.rb#117
+class SyntaxTree::YARV::Compiler::RubyVisitor::CompilationError < ::StandardError; end
+
+# ### Summary
+#
+# `concatarray` concatenates the two Arrays on top of the stack.
+#
+# It coerces the two objects at the top of the stack into Arrays by
+# calling `to_a` if necessary, and makes sure to `dup` the first Array if
+# it was already an Array, to avoid mutating it when concatenating.
+#
+# ### Usage
+#
+# ~~~ruby
+# [1, *2]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#674
+class SyntaxTree::YARV::ConcatArray < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#687
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#699
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#683
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#675
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#691
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#695
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#679
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `concatstrings` pops a number of strings from the stack joins them
+# together into a single string and pushes that string back on the stack.
+#
+# This does no coercion and so is always used in conjunction with
+# `objtostring` and `anytostring` to ensure the stack contents are always
+# strings.
+#
+# ### Usage
+#
+# ~~~ruby
+# "#{5}"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#720
+class SyntaxTree::YARV::ConcatStrings < ::SyntaxTree::YARV::Instruction
+ # @return [ConcatStrings] a new instance of ConcatStrings
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#723
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#739
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#755
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#735
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#727
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#743
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#721
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#747
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#751
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#731
+ def to_a(_iseq); end
+end
+
+# This class represents a control flow graph of a YARV instruction sequence.
+# It constructs a graph of basic blocks that hold subsets of the list of
+# instructions from the instruction sequence.
+#
+# You can use this class by calling the ::compile method and passing it a
+# YARV instruction sequence. It will return a control flow graph object.
+#
+# iseq = RubyVM::InstructionSequence.compile("1 + 2")
+# iseq = SyntaxTree::YARV::InstructionSequence.from(iseq.to_a)
+# cfg = SyntaxTree::YARV::ControlFlowGraph.compile(iseq)
+#
+# source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#16
+class SyntaxTree::YARV::ControlFlowGraph
+ # @return [ControlFlowGraph] a new instance of ControlFlowGraph
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#173
+ def initialize(iseq, insns, blocks); end
+
+ # This is the set of basic blocks that this control-flow graph contains.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#171
+ def blocks; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#179
+ def disasm; end
+
+ # This is the list of instructions that this control flow graph contains.
+ # It is effectively the same as the list of instructions in the
+ # instruction sequence but with line numbers and events filtered out.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#168
+ def insns; end
+
+ # This is the instruction sequence that this control flow graph
+ # corresponds to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#163
+ def iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#202
+ def to_dfg; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#210
+ def to_mermaid; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#206
+ def to_son; end
+
+ # This method is used to verify that the control flow graph is well
+ # formed. It does this by checking that each basic block is itself well
+ # formed.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#248
+ def verify; end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#252
+ def compile(iseq); end
+ end
+end
+
+# This class is responsible for creating a control flow graph from the
+# given instruction sequence.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#19
+class SyntaxTree::YARV::ControlFlowGraph::Compiler
+ # @return [Compiler] a new instance of Compiler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#34
+ def initialize(iseq); end
+
+ # This method is used to compile the instruction sequence into a control
+ # flow graph. It returns an instance of ControlFlowGraph.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#54
+ def compile; end
+
+ # This is a hash of indices in the YARV instruction sequence that point
+ # to their corresponding instruction.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#25
+ def insns; end
+
+ # This is the instruction sequence that is being compiled.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#21
+ def iseq; end
+
+ # This is a hash of labels that point to their corresponding index into
+ # the YARV instruction sequence. Note that this is not the same as the
+ # index into the list of instructions on the instruction sequence
+ # object. Instead, this is the index into the C array, so it includes
+ # operands.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#32
+ def labels; end
+
+ private
+
+ # Builds up a set of basic blocks by iterating over the starts of each
+ # block. They are keyed by the index of their first instruction.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#92
+ def build_basic_blocks; end
+
+ # Connect the blocks by letting them know which blocks are incoming and
+ # outgoing from each block.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#123
+ def connect_basic_blocks(blocks); end
+
+ # Finds the indices of the instructions that start a basic block because
+ # they're either:
+ #
+ # * the start of an instruction sequence
+ # * the target of a branch
+ # * fallen through to from a branch
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#72
+ def find_basic_block_starts; end
+
+ # If there are blocks that are unreachable, we can remove them from the
+ # graph entirely at this point.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/control_flow_graph.rb#145
+ def prune_basic_blocks(blocks); end
+end
+
+# Constructs a data-flow-graph of a YARV instruction sequence, via a
+# control-flow-graph. Data flow is discovered locally and then globally. The
+# graph only considers data flow through the stack - local variables and
+# objects are considered fully escaped in this analysis.
+#
+# You can use this class by calling the ::compile method and passing it a
+# control flow graph. It will return a data flow graph object.
+#
+# iseq = RubyVM::InstructionSequence.compile("1 + 2")
+# iseq = SyntaxTree::YARV::InstructionSequence.from(iseq.to_a)
+# cfg = SyntaxTree::YARV::ControlFlowGraph.compile(iseq)
+# dfg = SyntaxTree::YARV::DataFlowGraph.compile(cfg)
+#
+# source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#18
+class SyntaxTree::YARV::DataFlowGraph
+ # @return [DataFlowGraph] a new instance of DataFlowGraph
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#68
+ def initialize(cfg, insn_flows, block_flows); end
+
+ # Returns the value of attribute block_flows.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#66
+ def block_flows; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#74
+ def blocks; end
+
+ # Returns the value of attribute cfg.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#66
+ def cfg; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#78
+ def disasm; end
+
+ # Returns the value of attribute insn_flows.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#66
+ def insn_flows; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#127
+ def to_mermaid; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#123
+ def to_son; end
+
+ # Verify that we constructed the data flow graph correctly.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#179
+ def verify; end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#204
+ def compile(cfg); end
+ end
+end
+
+# This represents an object that goes on the stack that is passed between
+# basic blocks.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#32
+class SyntaxTree::YARV::DataFlowGraph::BlockArgument
+ # @return [BlockArgument] a new instance of BlockArgument
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#35
+ def initialize(name); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#39
+ def local?; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#33
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#43
+ def to_str; end
+end
+
+# This class is responsible for creating a data flow graph from the given
+# control flow graph.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#210
+class SyntaxTree::YARV::DataFlowGraph::Compiler
+ # @return [Compiler] a new instance of Compiler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#221
+ def initialize(cfg); end
+
+ # This data structure will hold the data flow between basic blocks.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#219
+ def block_flows; end
+
+ # This is the control flow graph that is being compiled.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#212
+ def cfg; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#227
+ def compile; end
+
+ # This data structure will hold the data flow between instructions
+ # within individual basic blocks.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#216
+ def insn_flows; end
+
+ private
+
+ # Find the data that flows between basic blocks.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#304
+ def find_external_flow; end
+
+ # Find the data flow within each basic block. Using an abstract stack,
+ # connect from consumers of data to the producers of that data.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#237
+ def find_internal_flow; end
+end
+
+# This object represents the flow of data between instructions.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#20
+class SyntaxTree::YARV::DataFlowGraph::DataFlow
+ # @return [DataFlow] a new instance of DataFlow
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#24
+ def initialize; end
+
+ # Returns the value of attribute in.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#21
+ def in; end
+
+ # Returns the value of attribute out.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#22
+ def out; end
+end
+
+# This represents an object that goes on the stack that is passed between
+# instructions within a basic block.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#50
+class SyntaxTree::YARV::DataFlowGraph::LocalArgument
+ # @return [LocalArgument] a new instance of LocalArgument
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#53
+ def initialize(length); end
+
+ # Returns the value of attribute length.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#51
+ def length; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#57
+ def local?; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#51
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/data_flow_graph.rb#61
+ def to_str; end
+end
+
+# This class is responsible for taking a compiled instruction sequence and
+# walking through it to generate equivalent Ruby code.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#7
+class SyntaxTree::YARV::Decompiler
+ include ::SyntaxTree::DSL
+
+ # @return [Decompiler] a new instance of Decompiler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#32
+ def initialize(iseq); end
+
+ # Returns the value of attribute block_label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#30
+ def block_label; end
+
+ # Returns the value of attribute iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#30
+ def iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#37
+ def to_ruby; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#52
+ def decompile(iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#256
+ def local_name(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#43
+ def node_for(value); end
+end
+
+# When we're decompiling, we use a looped case statement to emulate
+# jumping around in the same way the virtual machine would. This class
+# provides convenience methods for generating the AST nodes that have to
+# do with that label.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#12
+class SyntaxTree::YARV::Decompiler::BlockLabel
+ include ::SyntaxTree::DSL
+
+ # @return [BlockLabel] a new instance of BlockLabel
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#16
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#20
+ def field; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#14
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/decompiler.rb#24
+ def ref; end
+end
+
+# ### Summary
+#
+# `defineclass` defines a class. First it pops the superclass off the
+# stack, then it pops the object off the stack that the class should be
+# defined under. It has three arguments: the name of the constant, the
+# instruction sequence associated with the class, and various flags that
+# indicate if it is a singleton class, a module, or a regular class.
+#
+# ### Usage
+#
+# ~~~ruby
+# class Foo
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#775
+class SyntaxTree::YARV::DefineClass < ::SyntaxTree::YARV::Instruction
+ # @return [DefineClass] a new instance of DefineClass
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#784
+ def initialize(name, class_iseq, flags); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#806
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#823
+ def call(vm); end
+
+ # Returns the value of attribute class_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#782
+ def class_iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#802
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#790
+ def disasm(fmt); end
+
+ # Returns the value of attribute flags.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#782
+ def flags; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#811
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#782
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#815
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#819
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#798
+ def to_a(_iseq); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#780
+SyntaxTree::YARV::DefineClass::FLAG_HAS_SUPERCLASS = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#779
+SyntaxTree::YARV::DefineClass::FLAG_SCOPED = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#776
+SyntaxTree::YARV::DefineClass::TYPE_CLASS = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#778
+SyntaxTree::YARV::DefineClass::TYPE_MODULE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#777
+SyntaxTree::YARV::DefineClass::TYPE_SINGLETON_CLASS = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `definemethod` defines a method on the class of the current value of
+# `self`. It accepts two arguments. The first is the name of the method
+# being defined. The second is the instruction sequence representing the
+# body of the method.
+#
+# ### Usage
+#
+# ~~~ruby
+# def value = "value"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1068
+class SyntaxTree::YARV::DefineMethod < ::SyntaxTree::YARV::Instruction
+ # @return [DefineMethod] a new instance of DefineMethod
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1071
+ def initialize(method_name, method_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1092
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1101
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1088
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1076
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1097
+ def length; end
+
+ # Returns the value of attribute method_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1069
+ def method_iseq; end
+
+ # Returns the value of attribute method_name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1069
+ def method_name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1084
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `definesmethod` defines a method on the singleton class of the current
+# value of `self`. It accepts two arguments. The first is the name of the
+# method being defined. The second is the instruction sequence representing
+# the body of the method. It pops the object off the stack that the method
+# should be defined on.
+#
+# ### Usage
+#
+# ~~~ruby
+# def self.value = "value"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1137
+class SyntaxTree::YARV::DefineSMethod < ::SyntaxTree::YARV::Instruction
+ # @return [DefineSMethod] a new instance of DefineSMethod
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1140
+ def initialize(method_name, method_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1161
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1174
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1157
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1145
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1166
+ def length; end
+
+ # Returns the value of attribute method_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1138
+ def method_iseq; end
+
+ # Returns the value of attribute method_name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1138
+ def method_name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1170
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1153
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `defined` checks if the top value of the stack is defined. If it is, it
+# pushes its value onto the stack. Otherwise it pushes `nil`.
+#
+# ### Usage
+#
+# ~~~ruby
+# defined?(x)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#859
+class SyntaxTree::YARV::Defined < ::SyntaxTree::YARV::Instruction
+ # @return [Defined] a new instance of Defined
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#880
+ def initialize(type, name, message); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#939
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#956
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#935
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#886
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#944
+ def length; end
+
+ # Returns the value of attribute message.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#878
+ def message; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#878
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#948
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#952
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#931
+ def to_a(_iseq); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#878
+ def type; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#872
+SyntaxTree::YARV::Defined::TYPE_ASGN = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#865
+SyntaxTree::YARV::Defined::TYPE_CONST = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#876
+SyntaxTree::YARV::Defined::TYPE_CONST_FROM = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#864
+SyntaxTree::YARV::Defined::TYPE_CVAR = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#873
+SyntaxTree::YARV::Defined::TYPE_EXPR = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#871
+SyntaxTree::YARV::Defined::TYPE_FALSE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#875
+SyntaxTree::YARV::Defined::TYPE_FUNC = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#863
+SyntaxTree::YARV::Defined::TYPE_GVAR = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#861
+SyntaxTree::YARV::Defined::TYPE_IVAR = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#862
+SyntaxTree::YARV::Defined::TYPE_LVAR = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#866
+SyntaxTree::YARV::Defined::TYPE_METHOD = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#860
+SyntaxTree::YARV::Defined::TYPE_NIL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#874
+SyntaxTree::YARV::Defined::TYPE_REF = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#869
+SyntaxTree::YARV::Defined::TYPE_SELF = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#870
+SyntaxTree::YARV::Defined::TYPE_TRUE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#867
+SyntaxTree::YARV::Defined::TYPE_YIELD = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#868
+SyntaxTree::YARV::Defined::TYPE_ZSUPER = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `definedivar` checks if an instance variable is defined. It is a
+# specialization of the `defined` instruction. It accepts three arguments:
+# the name of the instance variable, an inline cache, and the string that
+# should be pushed onto the stack in the event that the instance variable
+# is defined.
+#
+# ### Usage
+#
+# ~~~ruby
+# defined?(@value)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1011
+class SyntaxTree::YARV::DefinedIVar < ::SyntaxTree::YARV::Instruction
+ # @return [DefinedIVar] a new instance of DefinedIVar
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1014
+ def initialize(name, cache, message); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1035
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1012
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1048
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1031
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1020
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1040
+ def length; end
+
+ # Returns the value of attribute message.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1012
+ def message; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1012
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1044
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1027
+ def to_a(_iseq); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#5
+class SyntaxTree::YARV::Disassembler
+ # @return [Disassembler] a new instance of Disassembler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#46
+ def initialize(current_iseq = T.unsafe(nil)); end
+
+ # Helpers for various instructions
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#58
+ def calldata(value); end
+
+ # Returns the value of attribute current_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#44
+ def current_iseq; end
+
+ # Sets the attribute current_iseq
+ #
+ # @param value the value to set the attribute current_iseq to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#44
+ def current_iseq=(_arg0); end
+
+ # Returns the value of attribute current_prefix.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#43
+ def current_prefix; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#62
+ def enqueue(iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#66
+ def event(name); end
+
+ # Entrypoints
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#116
+ def format!; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#123
+ def format_insns!(insns, length = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#87
+ def inline_storage(cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#91
+ def instruction(name, operands = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#95
+ def label(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#99
+ def local(index, explicit: T.unsafe(nil), implicit: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#108
+ def object(value); end
+
+ # Returns the value of attribute output.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#41
+ def output; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#167
+ def print(string); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#171
+ def puts(string); end
+
+ # Returns the value of attribute queue.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#41
+ def queue; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#175
+ def string; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#179
+ def with_prefix(value); end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#192
+ def format_iseq(iseq); end
+end
+
+# This class is another object that handles disassembling a YARV
+# instruction sequence but it renders it without any of the extra spacing
+# or alignment.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#9
+class SyntaxTree::YARV::Disassembler::Squished
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#10
+ def calldata(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#14
+ def enqueue(iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#17
+ def event(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#20
+ def inline_storage(cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#24
+ def instruction(name, operands = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#28
+ def label(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#32
+ def local(index, **_arg1); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/disassembler.rb#36
+ def object(value); end
+end
+
+# ### Summary
+#
+# `dup` copies the top value of the stack and pushes it onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# $global = 5
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1206
+class SyntaxTree::YARV::Dup < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1219
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1231
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1215
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1207
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1223
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1227
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1235
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1211
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `duparray` dups an Array literal and pushes it onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# [true]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1250
+class SyntaxTree::YARV::DupArray < ::SyntaxTree::YARV::Instruction
+ # @return [DupArray] a new instance of DupArray
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1253
+ def initialize(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1269
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1281
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1265
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1257
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1273
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1251
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1277
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1261
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `duphash` dups a Hash literal and pushes it onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# { a: 1 }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1296
+class SyntaxTree::YARV::DupHash < ::SyntaxTree::YARV::Instruction
+ # @return [DupHash] a new instance of DupHash
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1299
+ def initialize(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1315
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1327
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1311
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1303
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1319
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1297
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1323
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1307
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `dupn` duplicates the top `n` stack elements.
+#
+# ### Usage
+#
+# ~~~ruby
+# Object::X ||= true
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1342
+class SyntaxTree::YARV::DupN < ::SyntaxTree::YARV::Instruction
+ # @return [DupN] a new instance of DupN
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1345
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1361
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1373
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1357
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1349
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1365
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1343
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1369
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1353
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `expandarray` looks at the top of the stack, and if the value is an array
+# it replaces it on the stack with `number` elements of the array, or `nil`
+# if the elements are missing.
+#
+# ### Usage
+#
+# ~~~ruby
+# x, = [true, false, nil]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1392
+class SyntaxTree::YARV::ExpandArray < ::SyntaxTree::YARV::Instruction
+ # @return [ExpandArray] a new instance of ExpandArray
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1395
+ def initialize(number, flags); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1412
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1429
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1408
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1400
+ def disasm(fmt); end
+
+ # Returns the value of attribute flags.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1393
+ def flags; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1417
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1393
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1421
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1425
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1404
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `getblockparam` is a similar instruction to `getlocal` in that it looks
+# for a local variable in the current instruction sequence's local table and
+# walks recursively up the parent instruction sequences until it finds it.
+# The local it retrieves, however, is a special block local that was passed
+# to the current method. It pushes the value of the block local onto the
+# stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo(&block)
+# block
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1486
+class SyntaxTree::YARV::GetBlockParam < ::SyntaxTree::YARV::Instruction
+ # @return [GetBlockParam] a new instance of GetBlockParam
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1489
+ def initialize(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1508
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1521
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1504
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1494
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1487
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1513
+ def length; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1487
+ def level; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1517
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1498
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `getblockparamproxy` is almost the same as `getblockparam` except that it
+# pushes a proxy object onto the stack instead of the actual value of the
+# block local. This is used when a method is being called on the block
+# local.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo(&block)
+# block.call
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1541
+class SyntaxTree::YARV::GetBlockParamProxy < ::SyntaxTree::YARV::Instruction
+ # @return [GetBlockParamProxy] a new instance of GetBlockParamProxy
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1544
+ def initialize(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1566
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1579
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1562
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1549
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1542
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1571
+ def length; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1542
+ def level; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1575
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1556
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `getclassvariable` looks for a class variable in the current class and
+# pushes its value onto the stack. It uses an inline cache to reduce the
+# need to lookup the class variable in the class hierarchy every time.
+#
+# ### Usage
+#
+# ~~~ruby
+# @@class_variable
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1596
+class SyntaxTree::YARV::GetClassVariable < ::SyntaxTree::YARV::Instruction
+ # @return [GetClassVariable] a new instance of GetClassVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1599
+ def initialize(name, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1619
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1597
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1632
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1615
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1604
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1624
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1597
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1628
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1611
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `getconstant` performs a constant lookup and pushes the value of the
+# constant onto the stack. It pops both the class it should look in and
+# whether or not it should look globally as well.
+#
+# ### Usage
+#
+# ~~~ruby
+# Constant
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1651
+class SyntaxTree::YARV::GetConstant < ::SyntaxTree::YARV::Instruction
+ # @return [GetConstant] a new instance of GetConstant
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1654
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1670
+ def ==(other); end
+
+ # @raise [NameError]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1686
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1666
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1658
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1674
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1652
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1678
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1682
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1662
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `getglobal` pushes the value of a global variables onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# $$
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1717
+class SyntaxTree::YARV::GetGlobal < ::SyntaxTree::YARV::Instruction
+ # @return [GetGlobal] a new instance of GetGlobal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1720
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1736
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1748
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1732
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1724
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1740
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1718
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1744
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1728
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `getinstancevariable` pushes the value of an instance variable onto the
+# stack. It uses an inline cache to avoid having to look up the instance
+# variable in the class hierarchy every time.
+#
+# This instruction has two forms, but both have the same structure. Before
+# Ruby 3.2, the inline cache corresponded to both the get and set
+# instructions and could be shared. Since Ruby 3.2, it uses object shapes
+# instead so the caches are unique per instruction.
+#
+# ### Usage
+#
+# ~~~ruby
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1772
+class SyntaxTree::YARV::GetInstanceVariable < ::SyntaxTree::YARV::Instruction
+ # @return [GetInstanceVariable] a new instance of GetInstanceVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1775
+ def initialize(name, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1795
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1773
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1808
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1791
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1780
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1800
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1773
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1804
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1787
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `getlocal` fetches the value of a local variable from a frame determined
+# by the level and index arguments. The level is the number of frames back
+# to look and the index is the index in the local table. It pushes the value
+# it finds onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# tap { tap { value } }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1828
+class SyntaxTree::YARV::GetLocal < ::SyntaxTree::YARV::Instruction
+ # @return [GetLocal] a new instance of GetLocal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1831
+ def initialize(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1850
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1862
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1846
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1836
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1829
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1854
+ def length; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1829
+ def level; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1858
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1840
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `getlocal_WC_0` is a specialized version of the `getlocal` instruction. It
+# fetches the value of a local variable from the current frame determined by
+# the index given as its only argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# value
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1880
+class SyntaxTree::YARV::GetLocalWC0 < ::SyntaxTree::YARV::Instruction
+ # @return [GetLocalWC0] a new instance of GetLocalWC0
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1883
+ def initialize(index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1899
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1915
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1911
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1895
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1887
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1881
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1903
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1907
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1891
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `getlocal_WC_1` is a specialized version of the `getlocal` instruction. It
+# fetches the value of a local variable from the parent frame determined by
+# the index given as its only argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# self.then { value }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1933
+class SyntaxTree::YARV::GetLocalWC1 < ::SyntaxTree::YARV::Instruction
+ # @return [GetLocalWC1] a new instance of GetLocalWC1
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1936
+ def initialize(index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1952
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1968
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1964
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1948
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1940
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1934
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1956
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1960
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1944
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `getspecial` pushes the value of a special local variable onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# 1 if (a == 1) .. (b == 2)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1983
+class SyntaxTree::YARV::GetSpecial < ::SyntaxTree::YARV::Instruction
+ # @return [GetSpecial] a new instance of GetSpecial
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1990
+ def initialize(key, type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2007
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2019
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2003
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1995
+ def disasm(fmt); end
+
+ # Returns the value of attribute key.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1988
+ def key; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2011
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2015
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1999
+ def to_a(_iseq); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1988
+ def type; end
+end
+
+# $~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1985
+SyntaxTree::YARV::GetSpecial::SVAR_BACKREF = T.let(T.unsafe(nil), Integer)
+
+# flipflop
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1986
+SyntaxTree::YARV::GetSpecial::SVAR_FLIPFLOP_START = T.let(T.unsafe(nil), Integer)
+
+# $_
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#1984
+SyntaxTree::YARV::GetSpecial::SVAR_LASTLINE = T.let(T.unsafe(nil), Integer)
+
+# This is a base class for all YARV instructions. It provides a few
+# convenience methods for working with instructions.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#7
+class SyntaxTree::YARV::Instruction
+ # This returns an array of labels.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#33
+ def branch_targets; end
+
+ # This method creates an instruction that represents the canonical
+ # (non-specialized) form of this instruction. If this instruction is not
+ # a specialized instruction, then this method returns `self`.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#11
+ def canonical; end
+
+ # Whether or not this instruction falls through to the next instruction if
+ # its branching fails.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#44
+ def falls_through?; end
+
+ # Whether or not this instruction leaves the current frame.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#38
+ def leaves?; end
+
+ # This returns the size of the instruction in terms of the number of slots
+ # it occupies in the instruction sequence. Effectively this is 1 plus the
+ # number of operands.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#18
+ def length; end
+
+ # This returns the number of values that are popped off the stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#28
+ def pops; end
+
+ # This returns the number of values that are pushed onto the stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#23
+ def pushes; end
+
+ # Does the instruction have side effects? Control-flow counts as a
+ # side-effect, as do some special-case instructions like Leave. By default
+ # every instruction is marked as having side effects.
+ #
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#51
+ def side_effects?; end
+end
+
+# This class is meant to mirror RubyVM::InstructionSequence. It contains a
+# list of instructions along with the metadata pertaining to them. It also
+# functions as a builder for the instruction sequence.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#9
+class SyntaxTree::YARV::InstructionSequence
+ # @return [InstructionSequence] a new instance of InstructionSequence
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#168
+ def initialize(name, file, line, type, parent_iseq = T.unsafe(nil), options = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#652
+ def adjuststack(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#656
+ def anytostring; end
+
+ # Returns the value of attribute argument_options.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#143
+ def argument_options; end
+
+ # This is the list of information about the arguments to this
+ # instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#142
+ def argument_size; end
+
+ # This is the list of information about the arguments to this
+ # instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#142
+ def argument_size=(_arg0); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#472
+ def block_child_iseq(line); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#660
+ def branchif(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#664
+ def branchnil(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#668
+ def branchunless(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#565
+ def catch_break(iseq, begin_label, end_label, exit_label, restore_sp); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#575
+ def catch_ensure(iseq, begin_label, end_label, exit_label, restore_sp); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#585
+ def catch_next(begin_label, end_label, exit_label, restore_sp); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#595
+ def catch_redo(begin_label, end_label, exit_label, restore_sp); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#605
+ def catch_rescue(iseq, begin_label, end_label, exit_label, restore_sp); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#615
+ def catch_retry(begin_label, end_label, exit_label, restore_sp); end
+
+ # The catch table for this instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#146
+ def catch_table; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#672
+ def checkkeyword(keyword_bits_index, keyword_index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#676
+ def checkmatch(type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#680
+ def checktype(type); end
+
+ # Child instruction sequence methods
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#468
+ def child_iseq(name, line, type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#478
+ def class_child_iseq(name, line); end
+
+ # This method converts our linked list of instructions into a final array
+ # and performs any other compilation steps necessary.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#305
+ def compile!; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#684
+ def concatarray; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#688
+ def concatstrings(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#692
+ def defineclass(name, class_iseq, flags); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#696
+ def defined(type, name, message); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#700
+ def definedivar(name, cache, message); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#709
+ def definemethod(name, method_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#713
+ def definesmethod(name, method_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#292
+ def disasm; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#717
+ def dup; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#721
+ def duparray(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#725
+ def duphash(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#729
+ def dupn(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#232
+ def eval; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#648
+ def event(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#733
+ def expandarray(length, flags); end
+
+ # The source location of the instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#132
+ def file; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#737
+ def getblockparam(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#741
+ def getblockparamproxy(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#745
+ def getclassvariable(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#753
+ def getconstant(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#757
+ def getglobal(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#761
+ def getinstancevariable(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#769
+ def getlocal(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#788
+ def getspecial(key, type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#207
+ def inline_storage; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#213
+ def inline_storage_for(name); end
+
+ # The hash of names of instance and class variables pointing to the
+ # index of their associated inline storage.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#156
+ def inline_storages; end
+
+ # The list of instructions for this instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#149
+ def insns; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#299
+ def inspect; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#792
+ def intern; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#796
+ def invokeblock(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#800
+ def invokesuper(calldata, block_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#804
+ def jump(label); end
+
+ # Instruction push methods
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#629
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#808
+ def leave; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#219
+ def length; end
+
+ # The source location of the instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#132
+ def line; end
+
+ # The table of local variables.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#152
+ def local_table; end
+
+ # Query methods
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#199
+ def local_variable(name, level = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#482
+ def method_child_iseq(name, line); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#486
+ def module_child_iseq(name, line); end
+
+ # The name of the instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#129
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#812
+ def newarray(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#816
+ def newarraykwsplat(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#820
+ def newhash(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#824
+ def newrange(exclude_end); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#828
+ def nop; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#832
+ def objtostring(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#836
+ def once(iseq, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#840
+ def opt_aref_with(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#844
+ def opt_aset_with(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#848
+ def opt_case_dispatch(case_dispatch_hash, else_label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#852
+ def opt_getconstant_path(names); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#888
+ def opt_getinlinecache(label, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#892
+ def opt_setinlinecache(cache); end
+
+ # These are various compilation options provided.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#166
+ def options; end
+
+ # The parent instruction sequence, if there is one.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#138
+ def parent_iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#896
+ def pop; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#633
+ def push(value); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#900
+ def putnil; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#904
+ def putobject(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#922
+ def putself; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#926
+ def putspecialobject(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#930
+ def putstring(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#934
+ def send(calldata, block_iseq = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#938
+ def setblockparam(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#942
+ def setclassvariable(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#950
+ def setconstant(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#954
+ def setglobal(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#958
+ def setinstancevariable(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#966
+ def setlocal(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#985
+ def setn(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#989
+ def setspecial(key); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#490
+ def singleton_class_child_iseq(line); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#341
+ def specialize_instructions!; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#993
+ def splatarray(flag); end
+
+ # An object that will track the current size of the stack and the
+ # maximum size of the stack for this instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#163
+ def stack; end
+
+ # The index of the next inline storage that will be created.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#159
+ def storage_index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#997
+ def swap; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#1001
+ def throw(type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#236
+ def to_a; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#280
+ def to_cfg; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#284
+ def to_dfg; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#288
+ def to_son; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#1005
+ def topn(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#1009
+ def toregexp(options, length); end
+
+ # The type of the instruction sequence.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#135
+ def type; end
+
+ class << self
+ # This method will create a new instruction sequence from a serialized
+ # RubyVM::InstructionSequence object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#1015
+ def from(source, options = T.unsafe(nil), parent_iseq = T.unsafe(nil)); end
+
+ # This provides a handle to the rb_iseq_load function, which allows you
+ # to pass a serialized iseq to Ruby and have it return a
+ # RubyVM::InstructionSequence object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#13
+ def iseq_load(iseq); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#510
+class SyntaxTree::YARV::InstructionSequence::CatchBreak < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#511
+ def to_a; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#523
+class SyntaxTree::YARV::InstructionSequence::CatchEnsure < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#524
+ def to_a; end
+end
+
+# Catch table methods
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#498
+class SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # @return [CatchEntry] a new instance of CatchEntry
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#501
+ def initialize(iseq, begin_label, end_label, exit_label, restore_sp); end
+
+ # Returns the value of attribute begin_label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#499
+ def begin_label; end
+
+ # Returns the value of attribute end_label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#499
+ def end_label; end
+
+ # Returns the value of attribute exit_label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#499
+ def exit_label; end
+
+ # Returns the value of attribute iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#499
+ def iseq; end
+
+ # Returns the value of attribute restore_sp.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#499
+ def restore_sp; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#535
+class SyntaxTree::YARV::InstructionSequence::CatchNext < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#536
+ def to_a; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#541
+class SyntaxTree::YARV::InstructionSequence::CatchRedo < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#542
+ def to_a; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#547
+class SyntaxTree::YARV::InstructionSequence::CatchRescue < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#548
+ def to_a; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#559
+class SyntaxTree::YARV::InstructionSequence::CatchRetry < ::SyntaxTree::YARV::InstructionSequence::CatchEntry
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#560
+ def to_a; end
+end
+
+# When the list of instructions is first being created, it's stored as a
+# linked list. This is to make it easier to perform peephole optimizations
+# and other transformations like instruction specialization.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#35
+class SyntaxTree::YARV::InstructionSequence::InstructionList
+ include ::Enumerable
+
+ # @return [InstructionList] a new instance of InstructionList
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#48
+ def initialize; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#53
+ def each(&_blk); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#58
+ def each_node; end
+
+ # Returns the value of attribute head_node.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#46
+ def head_node; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#68
+ def push(instruction); end
+
+ # Returns the value of attribute tail_node.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#46
+ def tail_node; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#36
+class SyntaxTree::YARV::InstructionSequence::InstructionList::Node
+ # @return [Node] a new instance of Node
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#39
+ def initialize(value, next_node = T.unsafe(nil)); end
+
+ # Returns the value of attribute next_node.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#37
+ def next_node; end
+
+ # Sets the attribute next_node
+ #
+ # @param value the value to set the attribute next_node to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#37
+ def next_node=(_arg0); end
+
+ # Returns the value of attribute value.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#37
+ def value; end
+
+ # Sets the attribute value
+ #
+ # @param value the value to set the attribute value to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#37
+ def value=(_arg0); end
+end
+
+# This represents the destination of instructions that jump. Initially it
+# does not track its position so that when we perform optimizations the
+# indices don't get messed up.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#107
+class SyntaxTree::YARV::InstructionSequence::Label
+ # @return [Label] a new instance of Label
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#115
+ def initialize(name = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#123
+ def inspect; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#108
+ def name; end
+
+ # When we're serializing the instruction sequence, we need to be able to
+ # look up the label from the branch instructions and then access the
+ # subsequent node. So we'll store the reference here.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#113
+ def node; end
+
+ # When we're serializing the instruction sequence, we need to be able to
+ # look up the label from the branch instructions and then access the
+ # subsequent node. So we'll store the reference here.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#113
+ def node=(_arg0); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#119
+ def patch!(name); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#83
+SyntaxTree::YARV::InstructionSequence::MAGIC = T.let(T.unsafe(nil), String)
+
+# This object is used to track the size of the stack at any given time. It
+# is effectively a mini symbolic interpreter. It's necessary because when
+# instruction sequences get serialized they include a :stack_max field on
+# them. This field is used to determine how much stack space to allocate
+# for the instruction sequence.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#90
+class SyntaxTree::YARV::InstructionSequence::Stack
+ # @return [Stack] a new instance of Stack
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#93
+ def initialize; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#98
+ def change_by(value); end
+
+ # Returns the value of attribute current_size.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#91
+ def current_size; end
+
+ # Returns the value of attribute maximum_size.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instruction_sequence.rb#91
+ def maximum_size; end
+end
+
+# ### Summary
+#
+# `intern` converts the top element of the stack to a symbol and pushes the
+# symbol onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# :"#{"foo"}"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2042
+class SyntaxTree::YARV::Intern < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2055
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2067
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2051
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2043
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2059
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2063
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2047
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `invokeblock` invokes the block given to the current method. It pops the
+# arguments for the block off the stack and pushes the result of running the
+# block onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo
+# yield
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2086
+class SyntaxTree::YARV::InvokeBlock < ::SyntaxTree::YARV::Instruction
+ # @return [InvokeBlock] a new instance of InvokeBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2089
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2105
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2121
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2087
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2101
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2093
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2109
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2113
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2117
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2097
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `invokesuper` is similar to the `send` instruction, except that it calls
+# the super method. It pops the receiver and arguments off the stack and
+# pushes the return value onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo
+# super
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2140
+class SyntaxTree::YARV::InvokeSuper < ::SyntaxTree::YARV::Instruction
+ # @return [InvokeSuper] a new instance of InvokeSuper
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2143
+ def initialize(calldata, block_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2164
+ def ==(other); end
+
+ # Returns the value of attribute block_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2141
+ def block_iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2178
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2141
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2160
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2148
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2169
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2174
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2156
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `jump` unconditionally jumps to the label given as its only argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = 0
+# if x == 0
+# puts "0"
+# else
+# puts "2"
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2217
+class SyntaxTree::YARV::Jump < ::SyntaxTree::YARV::Instruction
+ # @return [Jump] a new instance of Jump
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2220
+ def initialize(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2236
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2248
+ def branch_targets; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2244
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2232
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2224
+ def disasm(fmt); end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2218
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2240
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2228
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `leave` exits the current frame.
+#
+# ### Usage
+#
+# ~~~ruby
+# ;;
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2263
+class SyntaxTree::YARV::Leave < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2276
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2290
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2272
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2264
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2294
+ def leaves?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2280
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2284
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2268
+ def to_a(_iseq); end
+end
+
+# This module contains the instructions that used to be a part of YARV but
+# have been replaced or removed in more recent versions.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#7
+module SyntaxTree::YARV::Legacy; end
+
+# ### Summary
+#
+# `getclassvariable` looks for a class variable in the current class and
+# pushes its value onto the stack.
+#
+# This version of the `getclassvariable` instruction is no longer used
+# since in Ruby 3.0 it gained an inline cache.`
+#
+# ### Usage
+#
+# ~~~ruby
+# @@class_variable
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#22
+class SyntaxTree::YARV::Legacy::GetClassVariable < ::SyntaxTree::YARV::Instruction
+ # @return [GetClassVariable] a new instance of GetClassVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#25
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#41
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#57
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#53
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#37
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#29
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#45
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#23
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#49
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#33
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_getinlinecache` is a wrapper around a series of `putobject` and
+# `getconstant` instructions that allows skipping past them if the inline
+# cache is currently set. It pushes the value of the cache onto the stack
+# if it is set, otherwise it pushes `nil`.
+#
+# This instruction is no longer used since in Ruby 3.2 it was replaced by
+# the consolidated `opt_getconstant_path` instruction.
+#
+# ### Usage
+#
+# ~~~ruby
+# Constant
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#78
+class SyntaxTree::YARV::Legacy::OptGetInlineCache < ::SyntaxTree::YARV::Instruction
+ # @return [OptGetInlineCache] a new instance of OptGetInlineCache
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#81
+ def initialize(label, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#101
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#118
+ def branch_targets; end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#79
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#114
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#97
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#86
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#122
+ def falls_through?; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#79
+ def label; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#106
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#110
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#93
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_newarray_max` is a specialization that occurs when the `max` method
+# is called on an array literal. It pops the values of the array off the
+# stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# [a, b, c].max
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#139
+class SyntaxTree::YARV::Legacy::OptNewArrayMax < ::SyntaxTree::YARV::Instruction
+ # @return [OptNewArrayMax] a new instance of OptNewArrayMax
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#142
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#158
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#174
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#154
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#146
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#162
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#140
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#166
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#170
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#150
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_newarray_min` is a specialization that occurs when the `min` method
+# is called on an array literal. It pops the values of the array off the
+# stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# [a, b, c].min
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#191
+class SyntaxTree::YARV::Legacy::OptNewArrayMin < ::SyntaxTree::YARV::Instruction
+ # @return [OptNewArrayMin] a new instance of OptNewArrayMin
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#194
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#210
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#226
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#206
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#198
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#214
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#192
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#218
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#222
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#202
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_setinlinecache` sets an inline cache for a constant lookup. It pops
+# the value it should set off the top of the stack. It uses this value to
+# set the cache. It then pushes that value back onto the top of the stack.
+#
+# This instruction is no longer used since in Ruby 3.2 it was replaced by
+# the consolidated `opt_getconstant_path` instruction.
+#
+# ### Usage
+#
+# ~~~ruby
+# Constant
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#246
+class SyntaxTree::YARV::Legacy::OptSetInlineCache < ::SyntaxTree::YARV::Instruction
+ # @return [OptSetInlineCache] a new instance of OptSetInlineCache
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#249
+ def initialize(cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#265
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#247
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#281
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#261
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#253
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#269
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#273
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#277
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#257
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setclassvariable` looks for a class variable in the current class and
+# sets its value to the value it pops off the top of the stack.
+#
+# This version of the `setclassvariable` instruction is no longer used
+# since in Ruby 3.0 it gained an inline cache.
+#
+# ### Usage
+#
+# ~~~ruby
+# @@class_variable = 1
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#299
+class SyntaxTree::YARV::Legacy::SetClassVariable < ::SyntaxTree::YARV::Instruction
+ # @return [SetClassVariable] a new instance of SetClassVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#302
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#318
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#334
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#330
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#314
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#306
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#322
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#300
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#326
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/legacy.rb#310
+ def to_a(_iseq); end
+end
+
+# This represents every local variable associated with an instruction
+# sequence. There are two kinds of locals: plain locals that are what you
+# expect, and block proxy locals, which represent local variables
+# associated with blocks that were passed into the current instruction
+# sequence.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#10
+class SyntaxTree::YARV::LocalTable
+ # @return [LocalTable] a new instance of LocalTable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#43
+ def initialize; end
+
+ # Add a BlockLocal to the local table.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#73
+ def block(name); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#47
+ def empty?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#51
+ def find(name, level = T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#56
+ def has?(name); end
+
+ # Returns the value of attribute locals.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#41
+ def locals; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#64
+ def name_at(index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#60
+ def names; end
+
+ # This is the offset from the top of the stack where this local variable
+ # lives.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#84
+ def offset(index); end
+
+ # Add a PlainLocal to the local table.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#78
+ def plain(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#68
+ def size; end
+end
+
+# A local representing a block passed into the current instruction
+# sequence.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#13
+class SyntaxTree::YARV::LocalTable::BlockLocal
+ # @return [BlockLocal] a new instance of BlockLocal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#16
+ def initialize(name); end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#14
+ def name; end
+end
+
+# The result of looking up a local variable in the current local table.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#31
+class SyntaxTree::YARV::LocalTable::Lookup
+ # @return [Lookup] a new instance of Lookup
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#34
+ def initialize(local, index, level); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#32
+ def index; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#32
+ def level; end
+
+ # Returns the value of attribute local.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#32
+ def local; end
+end
+
+# A regular local variable.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#22
+class SyntaxTree::YARV::LocalTable::PlainLocal
+ # @return [PlainLocal] a new instance of PlainLocal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#25
+ def initialize(name); end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/local_table.rb#23
+ def name; end
+end
+
+# ### Summary
+#
+# `newarray` puts a new array initialized with `number` values from the
+# stack. It pops `number` values off the stack and pushes the array onto the
+# stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# ["string"]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2311
+class SyntaxTree::YARV::NewArray < ::SyntaxTree::YARV::Instruction
+ # @return [NewArray] a new instance of NewArray
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2314
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2330
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2346
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2326
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2318
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2334
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2312
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2338
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2342
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2322
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `newarraykwsplat` is a specialized version of `newarray` that takes a **
+# splat argument. It pops `number` values off the stack and pushes the array
+# onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# ["string", **{ foo: "bar" }]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2363
+class SyntaxTree::YARV::NewArrayKwSplat < ::SyntaxTree::YARV::Instruction
+ # @return [NewArrayKwSplat] a new instance of NewArrayKwSplat
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2366
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2382
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2398
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2378
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2370
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2386
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2364
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2390
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2394
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2374
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `newhash` puts a new hash onto the stack, using `number` elements from the
+# stack. `number` needs to be even. It pops `number` elements off the stack
+# and pushes a hash onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo(key, value)
+# { key => value }
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2417
+class SyntaxTree::YARV::NewHash < ::SyntaxTree::YARV::Instruction
+ # @return [NewHash] a new instance of NewHash
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2420
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2436
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2452
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2432
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2424
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2440
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2418
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2444
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2448
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2428
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `newrange` creates a new range object from the top two values on the
+# stack. It pops both of them off, and then pushes on the new range. It
+# takes one argument which is 0 if the end is included or 1 if the end value
+# is excluded.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = 0
+# y = 1
+# p (x..y), (x...y)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2472
+class SyntaxTree::YARV::NewRange < ::SyntaxTree::YARV::Instruction
+ # @return [NewRange] a new instance of NewRange
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2475
+ def initialize(exclude_end); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2491
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2507
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2487
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2479
+ def disasm(fmt); end
+
+ # Returns the value of attribute exclude_end.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2473
+ def exclude_end; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2495
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2499
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2503
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2483
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `nop` is a no-operation instruction. It is used to pad the instruction
+# sequence so there is a place for other instructions to jump to.
+#
+# ### Usage
+#
+# ~~~ruby
+# raise rescue true
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2523
+class SyntaxTree::YARV::Nop < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2536
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2540
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2532
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2524
+ def disasm(fmt); end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2543
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2528
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `objtostring` pops a value from the stack, calls `to_s` on that value and
+# then pushes the result back to the stack.
+#
+# It has various fast paths for classes like String, Symbol, Module, Class,
+# etc. For everything else it calls `to_s`.
+#
+# ### Usage
+#
+# ~~~ruby
+# "#{5}"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2562
+class SyntaxTree::YARV::ObjToString < ::SyntaxTree::YARV::Instruction
+ # @return [ObjToString] a new instance of ObjToString
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2565
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2581
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2597
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2563
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2577
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2569
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2585
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2589
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2593
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2573
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `once` is an instruction that wraps an instruction sequence and ensures
+# that is it only ever executed once for the lifetime of the program. It
+# uses a cache to ensure that it is only executed once. It pushes the result
+# of running the instruction sequence onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# END { puts "END" }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2615
+class SyntaxTree::YARV::Once < ::SyntaxTree::YARV::Instruction
+ # @return [Once] a new instance of Once
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2618
+ def initialize(iseq, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2636
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2616
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2648
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2632
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2623
+ def disasm(fmt); end
+
+ # Returns the value of attribute iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2616
+ def iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2640
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2644
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2628
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_and` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `&` operator is used. There is a fast path for if
+# both operands are integers. It pops both the receiver and the argument off
+# the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 & 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2668
+class SyntaxTree::YARV::OptAnd < ::SyntaxTree::YARV::Instruction
+ # @return [OptAnd] a new instance of OptAnd
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2671
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2687
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2707
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2669
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2703
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2683
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2675
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2691
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2695
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2699
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2679
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_aref` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `[]` operator is used. There are fast paths if the
+# receiver is an integer, array, or hash.
+#
+# ### Usage
+#
+# ~~~ruby
+# 7[2]
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2724
+class SyntaxTree::YARV::OptAref < ::SyntaxTree::YARV::Instruction
+ # @return [OptAref] a new instance of OptAref
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2727
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2743
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2763
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2725
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2759
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2739
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2731
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2747
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2751
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2755
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2735
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_aref_with` is a specialization of the `opt_aref` instruction that
+# occurs when the `[]` operator is used with a string argument known at
+# compile time. There are fast paths if the receiver is a hash. It pops the
+# receiver off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# { 'test' => true }['test']
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2781
+class SyntaxTree::YARV::OptArefWith < ::SyntaxTree::YARV::Instruction
+ # @return [OptArefWith] a new instance of OptArefWith
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2784
+ def initialize(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2804
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2821
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2782
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2800
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2789
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2809
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2782
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2813
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2817
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2796
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_aset` is an instruction for setting the hash value by the key in
+# the `recv[obj] = set` format. It is a specialization of the
+# `opt_send_without_block` instruction. It pops the receiver, the key, and
+# the value off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# {}[:key] = value
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2839
+class SyntaxTree::YARV::OptAset < ::SyntaxTree::YARV::Instruction
+ # @return [OptAset] a new instance of OptAset
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2842
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2858
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2878
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2840
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2874
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2854
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2846
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2862
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2866
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2870
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2850
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_aset_with` is an instruction for setting the hash value by the known
+# string key in the `recv[obj] = set` format. It pops the receiver and the
+# value off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# {}["key"] = value
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2895
+class SyntaxTree::YARV::OptAsetWith < ::SyntaxTree::YARV::Instruction
+ # @return [OptAsetWith] a new instance of OptAsetWith
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2898
+ def initialize(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2918
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2935
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2896
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2914
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2903
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2923
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2896
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2927
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2931
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2910
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_case_dispatch` is a branch instruction that moves the control flow
+# for case statements that have clauses where they can all be used as hash
+# keys for an internal hash.
+#
+# It has two arguments: the `case_dispatch_hash` and an `else_label`. It
+# pops one value off the stack: a hash key. `opt_case_dispatch` looks up the
+# key in the `case_dispatch_hash` and jumps to the corresponding label if
+# there is one. If there is no value in the `case_dispatch_hash`,
+# `opt_case_dispatch` jumps to the `else_label` index.
+#
+# ### Usage
+#
+# ~~~ruby
+# case 1
+# when 1
+# puts "foo"
+# else
+# puts "bar"
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2964
+class SyntaxTree::YARV::OptCaseDispatch < ::SyntaxTree::YARV::Instruction
+ # @return [OptCaseDispatch] a new instance of OptCaseDispatch
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2967
+ def initialize(case_dispatch_hash, else_label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2991
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3009
+ def branch_targets; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3005
+ def call(vm); end
+
+ # Returns the value of attribute case_dispatch_hash.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2965
+ def case_dispatch_hash; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2987
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2972
+ def disasm(fmt); end
+
+ # Returns the value of attribute else_label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2965
+ def else_label; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3013
+ def falls_through?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2997
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3001
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#2979
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_div` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `/` operator is used. There are fast paths for if
+# both operands are integers, or if both operands are floats. It pops both
+# the receiver and the argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 / 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3031
+class SyntaxTree::YARV::OptDiv < ::SyntaxTree::YARV::Instruction
+ # @return [OptDiv] a new instance of OptDiv
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3034
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3050
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3070
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3032
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3066
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3046
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3038
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3054
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3058
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3062
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3042
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_empty_p` is an optimization applied when the method `empty?` is
+# called. It pops the receiver off the stack and pushes on the result of the
+# method call.
+#
+# ### Usage
+#
+# ~~~ruby
+# "".empty?
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3087
+class SyntaxTree::YARV::OptEmptyP < ::SyntaxTree::YARV::Instruction
+ # @return [OptEmptyP] a new instance of OptEmptyP
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3090
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3106
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3126
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3088
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3122
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3102
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3094
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3110
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3114
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3118
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3098
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_eq` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the == operator is used. Fast paths exist when both
+# operands are integers, floats, symbols or strings. It pops both the
+# receiver and the argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 == 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3144
+class SyntaxTree::YARV::OptEq < ::SyntaxTree::YARV::Instruction
+ # @return [OptEq] a new instance of OptEq
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3147
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3163
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3183
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3145
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3179
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3159
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3151
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3167
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3171
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3175
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3155
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_ge` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the >= operator is used. Fast paths exist when both
+# operands are integers or floats. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 4 >= 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3201
+class SyntaxTree::YARV::OptGE < ::SyntaxTree::YARV::Instruction
+ # @return [OptGE] a new instance of OptGE
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3204
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3220
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3240
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3202
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3236
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3216
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3208
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3224
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3228
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3232
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3212
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_gt` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the > operator is used. Fast paths exist when both
+# operands are integers or floats. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 4 > 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3314
+class SyntaxTree::YARV::OptGT < ::SyntaxTree::YARV::Instruction
+ # @return [OptGT] a new instance of OptGT
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3317
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3333
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3353
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3315
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3349
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3329
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3321
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3337
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3341
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3345
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3325
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_getconstant_path` performs a constant lookup on a chain of constant
+# names. It accepts as its argument an array of constant names, and pushes
+# the value of the constant onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# ::Object
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3257
+class SyntaxTree::YARV::OptGetConstantPath < ::SyntaxTree::YARV::Instruction
+ # @return [OptGetConstantPath] a new instance of OptGetConstantPath
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3260
+ def initialize(names); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3277
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3289
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3273
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3264
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3281
+ def length; end
+
+ # Returns the value of attribute names.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3258
+ def names; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3285
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3269
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_le` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the <= operator is used. Fast paths exist when both
+# operands are integers or floats. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 3 <= 4
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3371
+class SyntaxTree::YARV::OptLE < ::SyntaxTree::YARV::Instruction
+ # @return [OptLE] a new instance of OptLE
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3374
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3390
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3410
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3372
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3406
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3386
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3378
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3394
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3398
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3402
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3382
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_lt` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the < operator is used. Fast paths exist when both
+# operands are integers or floats. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 3 < 4
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3485
+class SyntaxTree::YARV::OptLT < ::SyntaxTree::YARV::Instruction
+ # @return [OptLT] a new instance of OptLT
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3488
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3504
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3524
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3486
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3520
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3500
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3492
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3508
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3512
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3516
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3496
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_ltlt` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `<<` operator is used. Fast paths exists when the
+# receiver is either a String or an Array. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# "" << 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3542
+class SyntaxTree::YARV::OptLTLT < ::SyntaxTree::YARV::Instruction
+ # @return [OptLTLT] a new instance of OptLTLT
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3545
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3561
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3581
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3543
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3577
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3557
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3549
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3565
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3569
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3573
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3553
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_length` is a specialization of `opt_send_without_block`, when the
+# `length` method is called. There are fast paths when the receiver is
+# either a string, hash, or array. It pops the receiver off the stack and
+# pushes on the result of the method call.
+#
+# ### Usage
+#
+# ~~~ruby
+# "".length
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3428
+class SyntaxTree::YARV::OptLength < ::SyntaxTree::YARV::Instruction
+ # @return [OptLength] a new instance of OptLength
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3431
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3447
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3467
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3429
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3463
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3443
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3435
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3451
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3455
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3459
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3439
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_minus` is a specialization of the `opt_send_without_block`
+# instruction that occurs when the `-` operator is used. There are fast
+# paths for if both operands are integers or if both operands are floats. It
+# pops both the receiver and the argument off the stack and pushes on the
+# result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 3 - 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3600
+class SyntaxTree::YARV::OptMinus < ::SyntaxTree::YARV::Instruction
+ # @return [OptMinus] a new instance of OptMinus
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3603
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3619
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3639
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3601
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3635
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3615
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3607
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3623
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3627
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3631
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3611
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_mod` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `%` operator is used. There are fast paths for if
+# both operands are integers or if both operands are floats. It pops both
+# the receiver and the argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 4 % 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3657
+class SyntaxTree::YARV::OptMod < ::SyntaxTree::YARV::Instruction
+ # @return [OptMod] a new instance of OptMod
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3660
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3676
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3696
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3658
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3692
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3672
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3664
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3680
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3684
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3688
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3668
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_mult` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `*` operator is used. There are fast paths for if
+# both operands are integers or floats. It pops both the receiver and the
+# argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 3 * 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3714
+class SyntaxTree::YARV::OptMult < ::SyntaxTree::YARV::Instruction
+ # @return [OptMult] a new instance of OptMult
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3717
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3733
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3753
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3715
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3749
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3729
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3721
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3737
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3741
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3745
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3725
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_neq` is an optimization that tests whether two values at the top of
+# the stack are not equal by testing their equality and calling the `!` on
+# the result. This allows `opt_neq` to use the fast paths optimized in
+# `opt_eq` when both operands are Integers, Floats, Symbols, or Strings. It
+# pops both the receiver and the argument off the stack and pushes on the
+# result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 != 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3773
+class SyntaxTree::YARV::OptNEq < ::SyntaxTree::YARV::Instruction
+ # @return [OptNEq] a new instance of OptNEq
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3776
+ def initialize(eq_calldata, neq_calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3796
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3813
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3792
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3781
+ def disasm(fmt); end
+
+ # Returns the value of attribute eq_calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3774
+ def eq_calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3801
+ def length; end
+
+ # Returns the value of attribute neq_calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3774
+ def neq_calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3805
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3809
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3788
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_newarray_send` is a specialization that occurs when a dynamic array
+# literal is created and immediately sent the `min`, `max`, or `hash`
+# methods. It pops the values of the array off the stack and pushes on the
+# result of the method call.
+#
+# ### Usage
+#
+# ~~~ruby
+# [a, b, c].max
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3832
+class SyntaxTree::YARV::OptNewArraySend < ::SyntaxTree::YARV::Instruction
+ # @return [OptNewArraySend] a new instance of OptNewArraySend
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3835
+ def initialize(number, method); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3855
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3872
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3851
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3840
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3860
+ def length; end
+
+ # Returns the value of attribute method.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3833
+ def method; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3833
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3864
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3868
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3847
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_nil_p` is an optimization applied when the method `nil?` is called.
+# It returns true immediately when the receiver is `nil` and defers to the
+# `nil?` method in other cases. It pops the receiver off the stack and
+# pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# "".nil?
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3890
+class SyntaxTree::YARV::OptNilP < ::SyntaxTree::YARV::Instruction
+ # @return [OptNilP] a new instance of OptNilP
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3893
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3909
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3929
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3891
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3925
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3905
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3897
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3913
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3917
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3921
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3901
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_not` negates the value on top of the stack by calling the `!` method
+# on it. It pops the receiver off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# !true
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3945
+class SyntaxTree::YARV::OptNot < ::SyntaxTree::YARV::Instruction
+ # @return [OptNot] a new instance of OptNot
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3948
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3964
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3984
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3946
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3980
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3960
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3952
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3968
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3972
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3976
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#3956
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_or` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `|` operator is used. There is a fast path for if
+# both operands are integers. It pops both the receiver and the argument off
+# the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 | 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4002
+class SyntaxTree::YARV::OptOr < ::SyntaxTree::YARV::Instruction
+ # @return [OptOr] a new instance of OptOr
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4005
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4021
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4041
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4003
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4037
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4017
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4009
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4025
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4029
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4033
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4013
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_plus` is a specialization of the `opt_send_without_block` instruction
+# that occurs when the `+` operator is used. There are fast paths for if
+# both operands are integers, floats, strings, or arrays. It pops both the
+# receiver and the argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# 2 + 3
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4059
+class SyntaxTree::YARV::OptPlus < ::SyntaxTree::YARV::Instruction
+ # @return [OptPlus] a new instance of OptPlus
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4062
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4078
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4098
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4060
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4094
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4074
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4066
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4082
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4086
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4090
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4070
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_regexpmatch2` is a specialization of the `opt_send_without_block`
+# instruction that occurs when the `=~` operator is used. It pops both the
+# receiver and the argument off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# /a/ =~ "a"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4115
+class SyntaxTree::YARV::OptRegExpMatch2 < ::SyntaxTree::YARV::Instruction
+ # @return [OptRegExpMatch2] a new instance of OptRegExpMatch2
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4118
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4134
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4154
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4116
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4150
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4130
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4122
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4138
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4142
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4146
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4126
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_send_without_block` is a specialization of the send instruction that
+# occurs when a method is being called without a block. It pops the receiver
+# and the arguments off the stack and pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# puts "Hello, world!"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4171
+class SyntaxTree::YARV::OptSendWithoutBlock < ::SyntaxTree::YARV::Instruction
+ # @return [OptSendWithoutBlock] a new instance of OptSendWithoutBlock
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4174
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4190
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4210
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4172
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4206
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4186
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4178
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4194
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4198
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4202
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4182
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_size` is a specialization of `opt_send_without_block`, when the
+# `size` method is called. There are fast paths when the receiver is either
+# a string, hash, or array. It pops the receiver off the stack and pushes on
+# the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# "".size
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4228
+class SyntaxTree::YARV::OptSize < ::SyntaxTree::YARV::Instruction
+ # @return [OptSize] a new instance of OptSize
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4231
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4247
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4267
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4229
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4263
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4243
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4235
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4251
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4255
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4259
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4239
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_str_freeze` pushes a frozen known string value with no interpolation
+# onto the stack using the #freeze method. If the method gets overridden,
+# this will fall back to a send.
+#
+# ### Usage
+#
+# ~~~ruby
+# "hello".freeze
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4284
+class SyntaxTree::YARV::OptStrFreeze < ::SyntaxTree::YARV::Instruction
+ # @return [OptStrFreeze] a new instance of OptStrFreeze
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4287
+ def initialize(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4307
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4320
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4285
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4303
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4292
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4312
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4285
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4316
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4299
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_str_uminus` pushes a frozen known string value with no interpolation
+# onto the stack. If the method gets overridden, this will fall back to a
+# send.
+#
+# ### Usage
+#
+# ~~~ruby
+# -"string"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4337
+class SyntaxTree::YARV::OptStrUMinus < ::SyntaxTree::YARV::Instruction
+ # @return [OptStrUMinus] a new instance of OptStrUMinus
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4340
+ def initialize(object, calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4360
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4373
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4338
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4356
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4345
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4365
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4338
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4369
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4352
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `opt_succ` is a specialization of the `opt_send_without_block` instruction
+# when the method being called is `succ`. Fast paths exist when the receiver
+# is either a String or a Fixnum. It pops the receiver off the stack and
+# pushes on the result.
+#
+# ### Usage
+#
+# ~~~ruby
+# "".succ
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4391
+class SyntaxTree::YARV::OptSucc < ::SyntaxTree::YARV::Instruction
+ # @return [OptSucc] a new instance of OptSucc
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4394
+ def initialize(calldata); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4410
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4430
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4392
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4426
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4406
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4398
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4414
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4418
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4422
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4402
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `pop` pops the top value off the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# a ||= 2
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4445
+class SyntaxTree::YARV::Pop < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4458
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4466
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4454
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4446
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4462
+ def pops; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4470
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4450
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putnil` pushes a global nil object onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# nil
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4485
+class SyntaxTree::YARV::PutNil < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4498
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4510
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4506
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4494
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4486
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4502
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4514
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4490
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putobject` pushes a known value onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# 5
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4529
+class SyntaxTree::YARV::PutObject < ::SyntaxTree::YARV::Instruction
+ # @return [PutObject] a new instance of PutObject
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4532
+ def initialize(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4548
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4560
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4544
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4536
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4552
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4530
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4556
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4564
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4540
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putobject_INT2FIX_0_` pushes 0 on the stack. It is a specialized
+# instruction resulting from the operand unification optimization. It is
+# equivalent to `putobject 0`.
+#
+# ### Usage
+#
+# ~~~ruby
+# 0
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4581
+class SyntaxTree::YARV::PutObjectInt2Fix0 < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4594
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4606
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4602
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4590
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4582
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4598
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4610
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4586
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putobject_INT2FIX_1_` pushes 1 on the stack. It is a specialized
+# instruction resulting from the operand unification optimization. It is
+# equivalent to `putobject 1`.
+#
+# ### Usage
+#
+# ~~~ruby
+# 1
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4627
+class SyntaxTree::YARV::PutObjectInt2Fix1 < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4640
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4652
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4648
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4636
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4628
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4644
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4656
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4632
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putself` pushes the current value of self onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# puts "Hello, world!"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4671
+class SyntaxTree::YARV::PutSelf < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4684
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4692
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4680
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4672
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4688
+ def pushes; end
+
+ # @return [Boolean]
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4696
+ def side_effects?; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4676
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `putspecialobject` pushes one of three special objects onto the stack.
+# These are either the VM core special object, the class base special
+# object, or the constant base special object.
+#
+# ### Usage
+#
+# ~~~ruby
+# alias foo bar
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4713
+class SyntaxTree::YARV::PutSpecialObject < ::SyntaxTree::YARV::Instruction
+ # @return [PutSpecialObject] a new instance of PutSpecialObject
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4720
+ def initialize(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4736
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4748
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4732
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4724
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4740
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4718
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4744
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4728
+ def to_a(_iseq); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4715
+SyntaxTree::YARV::PutSpecialObject::OBJECT_CBASE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4716
+SyntaxTree::YARV::PutSpecialObject::OBJECT_CONST_BASE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4714
+SyntaxTree::YARV::PutSpecialObject::OBJECT_VMCORE = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `putstring` pushes an unfrozen string literal onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# "foo"
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4772
+class SyntaxTree::YARV::PutString < ::SyntaxTree::YARV::Instruction
+ # @return [PutString] a new instance of PutString
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4775
+ def initialize(object); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4791
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4803
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4787
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4779
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4795
+ def length; end
+
+ # Returns the value of attribute object.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4773
+ def object; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4799
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4783
+ def to_a(_iseq); end
+end
+
+# A sea of nodes is an intermediate representation used by a compiler to
+# represent both control and data flow in the same graph. The way we use it
+# allows us to have the vertices of the graph represent either an
+# instruction in the instruction sequence or a synthesized node that we add
+# to the graph. The edges of the graph represent either control flow or data
+# flow.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#11
+class SyntaxTree::YARV::SeaOfNodes
+ # @return [SeaOfNodes] a new instance of SeaOfNodes
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#462
+ def initialize(dfg, nodes, local_graphs); end
+
+ # Returns the value of attribute dfg.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#460
+ def dfg; end
+
+ # Returns the value of attribute local_graphs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#460
+ def local_graphs; end
+
+ # Returns the value of attribute nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#460
+ def nodes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#468
+ def to_mermaid; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#499
+ def verify; end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#529
+ def compile(dfg); end
+ end
+end
+
+# The compiler is responsible for taking a data flow graph and turning it
+# into a sea of nodes.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#100
+class SyntaxTree::YARV::SeaOfNodes::Compiler
+ # @return [Compiler] a new instance of Compiler
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#103
+ def initialize(dfg); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#113
+ def compile; end
+
+ # Returns the value of attribute dfg.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#101
+ def dfg; end
+
+ # Returns the value of attribute nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#101
+ def nodes; end
+
+ private
+
+ # Eliminate as many unnecessary nodes as we can.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#339
+ def cleanup_insn_nodes; end
+
+ # We don't always build things in an optimal way. Go back and fix up
+ # some mess we left. Ideally we wouldn't create these problems in the
+ # first place.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#315
+ def cleanup_phi_nodes; end
+
+ # Connect one node to another.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#423
+ def connect(from, to, type, label = T.unsafe(nil)); end
+
+ # Connect control flow that flows between basic blocks.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#246
+ def connect_local_graphs_control(local_graphs); end
+
+ # Connect data flow that flows between basic blocks.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#271
+ def connect_local_graphs_data(local_graphs); end
+
+ # Connect all of the inputs to all of the outputs of a node.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#433
+ def connect_over(node); end
+
+ # Create a sub-graph for a single basic block - block block argument
+ # inputs and outputs will be left dangling, to be connected later.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#136
+ def create_local_graph(block); end
+
+ # Counter for synthetic nodes.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#130
+ def id_counter; end
+
+ # Remove a node from the graph.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#447
+ def remove(node); end
+end
+
+# The edge of a graph represents either control flow or data flow.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#67
+class SyntaxTree::YARV::SeaOfNodes::Edge
+ # @return [Edge] a new instance of Edge
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#75
+ def initialize(from, to, type, label); end
+
+ # Returns the value of attribute from.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#70
+ def from; end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#73
+ def label; end
+
+ # Returns the value of attribute to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#71
+ def to; end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#72
+ def type; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#68
+SyntaxTree::YARV::SeaOfNodes::Edge::TYPES = T.let(T.unsafe(nil), Array)
+
+# This object represents a node in the graph that holds a YARV
+# instruction.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#14
+class SyntaxTree::YARV::SeaOfNodes::InsnNode
+ # @return [InsnNode] a new instance of InsnNode
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#17
+ def initialize(insn, offset); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#25
+ def id; end
+
+ # Returns the value of attribute inputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#15
+ def inputs; end
+
+ # Returns the value of attribute insn.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#15
+ def insn; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#29
+ def label; end
+
+ # Returns the value of attribute offset.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#15
+ def offset; end
+
+ # Returns the value of attribute outputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#15
+ def outputs; end
+end
+
+# Merge nodes are present in any block that has multiple incoming blocks.
+# It provides a place for Phi nodes to attach their results.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#52
+class SyntaxTree::YARV::SeaOfNodes::MergeNode
+ # @return [MergeNode] a new instance of MergeNode
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#55
+ def initialize(id); end
+
+ # Returns the value of attribute id.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#53
+ def id; end
+
+ # Returns the value of attribute inputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#53
+ def inputs; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#61
+ def label; end
+
+ # Returns the value of attribute outputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#53
+ def outputs; end
+end
+
+# Phi nodes are used to represent the merging of data flow from multiple
+# incoming blocks.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#36
+class SyntaxTree::YARV::SeaOfNodes::PhiNode
+ # @return [PhiNode] a new instance of PhiNode
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#39
+ def initialize(id); end
+
+ # Returns the value of attribute id.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#37
+ def id; end
+
+ # Returns the value of attribute inputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#37
+ def inputs; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#45
+ def label; end
+
+ # Returns the value of attribute outputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#37
+ def outputs; end
+end
+
+# A subgraph represents the local data and control flow of a single basic
+# block.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#87
+class SyntaxTree::YARV::SeaOfNodes::SubGraph
+ # @return [SubGraph] a new instance of SubGraph
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#90
+ def initialize(first_fixed, last_fixed, inputs, outputs); end
+
+ # Returns the value of attribute first_fixed.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#88
+ def first_fixed; end
+
+ # Returns the value of attribute inputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#88
+ def inputs; end
+
+ # Returns the value of attribute last_fixed.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#88
+ def last_fixed; end
+
+ # Returns the value of attribute outputs.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/sea_of_nodes.rb#88
+ def outputs; end
+end
+
+# ### Summary
+#
+# `send` invokes a method with an optional block. It pops its receiver and
+# the arguments for the method off the stack and pushes the return value
+# onto the stack. It has two arguments: the calldata for the call site and
+# the optional block instruction sequence.
+#
+# ### Usage
+#
+# ~~~ruby
+# "hello".tap { |i| p i }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4821
+class SyntaxTree::YARV::Send < ::SyntaxTree::YARV::Instruction
+ # @return [Send] a new instance of Send
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4824
+ def initialize(calldata, block_iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4845
+ def ==(other); end
+
+ # Returns the value of attribute block_iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4822
+ def block_iseq; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4863
+ def call(vm); end
+
+ # Returns the value of attribute calldata.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4822
+ def calldata; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4841
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4829
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4850
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4854
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4859
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4837
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setblockparam` sets the value of a block local variable on a frame
+# determined by the level and index arguments. The level is the number of
+# frames back to look and the index is the index in the local table. It pops
+# the value it is setting off the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# def foo(&bar)
+# bar = baz
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4905
+class SyntaxTree::YARV::SetBlockParam < ::SyntaxTree::YARV::Instruction
+ # @return [SetBlockParam] a new instance of SetBlockParam
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4908
+ def initialize(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4927
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4940
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4923
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4913
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4906
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4932
+ def length; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4906
+ def level; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4936
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4917
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `setclassvariable` looks for a class variable in the current class and
+# sets its value to the value it pops off the top of the stack. It uses an
+# inline cache to reduce the need to lookup the class variable in the class
+# hierarchy every time.
+#
+# ### Usage
+#
+# ~~~ruby
+# @@class_variable = 1
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4958
+class SyntaxTree::YARV::SetClassVariable < ::SyntaxTree::YARV::Instruction
+ # @return [SetClassVariable] a new instance of SetClassVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4961
+ def initialize(name, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4981
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4959
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4994
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4977
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4966
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4986
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4959
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4990
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#4973
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setconstant` pops two values off the stack: the value to set the
+# constant to and the constant base to set it in.
+#
+# ### Usage
+#
+# ~~~ruby
+# Constant = 1
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5012
+class SyntaxTree::YARV::SetConstant < ::SyntaxTree::YARV::Instruction
+ # @return [SetConstant] a new instance of SetConstant
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5015
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5031
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5043
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5027
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5019
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5035
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5013
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5039
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5023
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setglobal` sets the value of a global variable to a value popped off the
+# top of the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# $global = 5
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5060
+class SyntaxTree::YARV::SetGlobal < ::SyntaxTree::YARV::Instruction
+ # @return [SetGlobal] a new instance of SetGlobal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5063
+ def initialize(name); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5079
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5091
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5075
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5067
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5083
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5061
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5087
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5071
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setinstancevariable` pops a value off the top of the stack and then sets
+# the instance variable associated with the instruction to that value.
+#
+# This instruction has two forms, but both have the same structure. Before
+# Ruby 3.2, the inline cache corresponded to both the get and set
+# instructions and could be shared. Since Ruby 3.2, it uses object shapes
+# instead so the caches are unique per instruction.
+#
+# ### Usage
+#
+# ~~~ruby
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5114
+class SyntaxTree::YARV::SetInstanceVariable < ::SyntaxTree::YARV::Instruction
+ # @return [SetInstanceVariable] a new instance of SetInstanceVariable
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5117
+ def initialize(name, cache); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5137
+ def ==(other); end
+
+ # Returns the value of attribute cache.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5115
+ def cache; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5150
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5133
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5122
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5142
+ def length; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5115
+ def name; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5146
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5129
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setlocal` sets the value of a local variable on a frame determined by the
+# level and index arguments. The level is the number of frames back to
+# look and the index is the index in the local table. It pops the value it
+# is setting off the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# tap { tap { value = 10 } }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5170
+class SyntaxTree::YARV::SetLocal < ::SyntaxTree::YARV::Instruction
+ # @return [SetLocal] a new instance of SetLocal
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5173
+ def initialize(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5192
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5204
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5188
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5178
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5171
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5196
+ def length; end
+
+ # Returns the value of attribute level.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5171
+ def level; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5200
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5182
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `setlocal_WC_0` is a specialized version of the `setlocal` instruction. It
+# sets the value of a local variable on the current frame to the value at
+# the top of the stack as determined by the index given as its only
+# argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5222
+class SyntaxTree::YARV::SetLocalWC0 < ::SyntaxTree::YARV::Instruction
+ # @return [SetLocalWC0] a new instance of SetLocalWC0
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5225
+ def initialize(index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5241
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5257
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5253
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5237
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5229
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5223
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5245
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5249
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5233
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `setlocal_WC_1` is a specialized version of the `setlocal` instruction. It
+# sets the value of a local variable on the parent frame to the value at the
+# top of the stack as determined by the index given as its only argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# value = 5
+# self.then { value = 10 }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5275
+class SyntaxTree::YARV::SetLocalWC1 < ::SyntaxTree::YARV::Instruction
+ # @return [SetLocalWC1] a new instance of SetLocalWC1
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5278
+ def initialize(index); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5294
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5310
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5306
+ def canonical; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5290
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5282
+ def disasm(fmt); end
+
+ # Returns the value of attribute index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5276
+ def index; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5298
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5302
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5286
+ def to_a(iseq); end
+end
+
+# ### Summary
+#
+# `setn` sets a value in the stack to a value popped off the top of the
+# stack. It then pushes that value onto the top of the stack as well.
+#
+# ### Usage
+#
+# ~~~ruby
+# {}[:key] = 'val'
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5326
+class SyntaxTree::YARV::SetN < ::SyntaxTree::YARV::Instruction
+ # @return [SetN] a new instance of SetN
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5329
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5345
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5361
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5341
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5333
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5349
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5327
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5353
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5357
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5337
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `setspecial` pops a value off the top of the stack and sets a special
+# local variable to that value. The special local variable is determined by
+# the key given as its only argument.
+#
+# ### Usage
+#
+# ~~~ruby
+# baz if (foo == 1) .. (bar == 1)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5378
+class SyntaxTree::YARV::SetSpecial < ::SyntaxTree::YARV::Instruction
+ # @return [SetSpecial] a new instance of SetSpecial
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5381
+ def initialize(key); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5397
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5409
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5393
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5385
+ def disasm(fmt); end
+
+ # Returns the value of attribute key.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5379
+ def key; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5401
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5405
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5389
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `splatarray` coerces the array object at the top of the stack into Array
+# by calling `to_a`. It pushes a duplicate of the array if there is a flag,
+# and the original array if there isn't one.
+#
+# ### Usage
+#
+# ~~~ruby
+# x = *(5)
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5433
+class SyntaxTree::YARV::SplatArray < ::SyntaxTree::YARV::Instruction
+ # @return [SplatArray] a new instance of SplatArray
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5436
+ def initialize(flag); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5452
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5468
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5448
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5440
+ def disasm(fmt); end
+
+ # Returns the value of attribute flag.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5434
+ def flag; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5456
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5460
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5464
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5444
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `swap` swaps the top two elements in the stack.
+#
+# ### TracePoint
+#
+# `swap` does not dispatch any events.
+#
+# ### Usage
+#
+# ~~~ruby
+# !!defined?([[]])
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5507
+class SyntaxTree::YARV::Swap < ::SyntaxTree::YARV::Instruction
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5520
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5532
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5516
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5508
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5524
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5528
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5512
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `throw` pops a value off the top of the stack and throws it. It is caught
+# using the instruction sequence's (or an ancestor's) catch table. It pushes
+# on the result of throwing the value.
+#
+# ### Usage
+#
+# ~~~ruby
+# [1, 2, 3].map { break 2 }
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5550
+class SyntaxTree::YARV::Throw < ::SyntaxTree::YARV::Instruction
+ # @return [Throw] a new instance of Throw
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5566
+ def initialize(type); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5582
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5598
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5578
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5570
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5586
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5590
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5594
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5574
+ def to_a(_iseq); end
+
+ # Returns the value of attribute type.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5564
+ def type; end
+
+ private
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5625
+ def error_backtrace(vm); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5553
+SyntaxTree::YARV::Throw::RUBY_TAG_BREAK = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5559
+SyntaxTree::YARV::Throw::RUBY_TAG_FATAL = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5554
+SyntaxTree::YARV::Throw::RUBY_TAG_NEXT = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5551
+SyntaxTree::YARV::Throw::RUBY_TAG_NONE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5557
+SyntaxTree::YARV::Throw::RUBY_TAG_RAISE = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5556
+SyntaxTree::YARV::Throw::RUBY_TAG_REDO = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5555
+SyntaxTree::YARV::Throw::RUBY_TAG_RETRY = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5552
+SyntaxTree::YARV::Throw::RUBY_TAG_RETURN = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5558
+SyntaxTree::YARV::Throw::RUBY_TAG_THROW = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5561
+SyntaxTree::YARV::Throw::VM_THROW_NO_ESCAPE_FLAG = T.let(T.unsafe(nil), Integer)
+
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5562
+SyntaxTree::YARV::Throw::VM_THROW_STATE_MASK = T.let(T.unsafe(nil), Integer)
+
+# ### Summary
+#
+# `toregexp` pops a number of values off the stack, combines them into a new
+# regular expression, and pushes the new regular expression onto the stack.
+#
+# ### Usage
+#
+# ~~~ruby
+# /foo #{bar}/
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5700
+class SyntaxTree::YARV::ToRegExp < ::SyntaxTree::YARV::Instruction
+ # @return [ToRegExp] a new instance of ToRegExp
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5703
+ def initialize(options, length); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5720
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5733
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5716
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5708
+ def disasm(fmt); end
+
+ # Returns the value of attribute length.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5701
+ def length; end
+
+ # Returns the value of attribute options.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5701
+ def options; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5725
+ def pops; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5729
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5712
+ def to_a(_iseq); end
+end
+
+# ### Summary
+#
+# `topn` pushes a single value onto the stack that is a copy of the value
+# within the stack that is `number` of slots down from the top.
+#
+# ### Usage
+#
+# ~~~ruby
+# case 3
+# when 1..5
+# puts "foo"
+# end
+# ~~~
+#
+# source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5653
+class SyntaxTree::YARV::TopN < ::SyntaxTree::YARV::Instruction
+ # @return [TopN] a new instance of TopN
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5656
+ def initialize(number); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5672
+ def ==(other); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5684
+ def call(vm); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5668
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5660
+ def disasm(fmt); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5676
+ def length; end
+
+ # Returns the value of attribute number.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5654
+ def number; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5680
+ def pushes; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/instructions.rb#5664
+ def to_a(_iseq); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#8
+class SyntaxTree::YARV::VM
+ extend ::Forwardable
+
+ # @return [VM] a new instance of VM
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#216
+ def initialize(events = T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#623
+ def catch(tag, &block); end
+
+ # Helper methods for instructions
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#494
+ def const_base; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#610
+ def eval(source, binding = T.unsafe(nil), filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
+
+ # Returns the value of attribute events.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#209
+ def events; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#344
+ def find_catch_entry(frame, type); end
+
+ # Returns the value of attribute frame.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#214
+ def frame; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#498
+ def frame_at(level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#504
+ def frame_svar; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#510
+ def frame_yield; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#516
+ def frozen_core; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#520
+ def jump(label); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#524
+ def leave; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#606
+ def load(filepath); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#528
+ def local_get(index, level); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#532
+ def local_set(index, level, value); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def pop(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def push(*args, **_arg1, &block); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#598
+ def require(filepath); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#549
+ def require_internal(filepath, loading: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#602
+ def require_relative(filepath); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#543
+ def require_resolved(filepath); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#360
+ def run_block_frame(iseq, frame, *args, **kwargs, &block); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#366
+ def run_class_frame(iseq, clazz); end
+
+ # Helper methods for frames
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#230
+ def run_frame(frame); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#370
+ def run_method_frame(name, nesting, iseq, _self, *args, **kwargs, &block); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#384
+ def run_rescue_frame(iseq, frame, error); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#356
+ def run_top_frame(iseq); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#391
+ def setup_arguments(iseq, args, kwargs, block); end
+
+ # Returns the value of attribute stack.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#211
+ def stack; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#619
+ def throw(tag, value = T.unsafe(nil)); end
+
+ class << self
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#222
+ def run(iseq); end
+ end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#48
+class SyntaxTree::YARV::VM::BlockFrame < ::SyntaxTree::YARV::VM::Frame
+ # @return [BlockFrame] a new instance of BlockFrame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#49
+ def initialize(iseq, parent, stack_index); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#89
+class SyntaxTree::YARV::VM::BreakError < ::SyntaxTree::YARV::VM::ThrownError; end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#64
+class SyntaxTree::YARV::VM::ClassFrame < ::SyntaxTree::YARV::VM::Frame
+ # @return [ClassFrame] a new instance of ClassFrame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#65
+ def initialize(iseq, parent, stack_index, _self); end
+end
+
+# Methods for overriding runtime behavior
+#
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#540
+SyntaxTree::YARV::VM::DLEXT = T.let(T.unsafe(nil), String)
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#205
+SyntaxTree::YARV::VM::FROZEN_CORE = T.let(T.unsafe(nil), SyntaxTree::YARV::VM::FrozenCore)
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#25
+class SyntaxTree::YARV::VM::Frame
+ # @return [Frame] a new instance of Frame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#29
+ def initialize(iseq, parent, stack_index, _self, nesting); end
+
+ # Returns the value of attribute _self.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def _self; end
+
+ # Returns the value of attribute iseq.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def iseq; end
+
+ # Returns the value of attribute line.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#27
+ def line; end
+
+ # Sets the attribute line
+ #
+ # @param value the value to set the attribute line to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#27
+ def line=(_arg0); end
+
+ # Returns the value of attribute nesting.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def nesting; end
+
+ # Returns the value of attribute parent.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def parent; end
+
+ # Returns the value of attribute pc.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#27
+ def pc; end
+
+ # Sets the attribute pc
+ #
+ # @param value the value to set the attribute pc to.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#27
+ def pc=(_arg0); end
+
+ # Returns the value of attribute stack_index.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def stack_index; end
+
+ # Returns the value of attribute svars.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#26
+ def svars; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#95
+class SyntaxTree::YARV::VM::FrozenCore; end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#9
+class SyntaxTree::YARV::VM::Jump
+ # @return [Jump] a new instance of Jump
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#12
+ def initialize(label); end
+
+ # Returns the value of attribute label.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#10
+ def label; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#17
+class SyntaxTree::YARV::VM::Leave
+ # @return [Leave] a new instance of Leave
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#20
+ def initialize(value); end
+
+ # Returns the value of attribute value.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#18
+ def value; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#54
+class SyntaxTree::YARV::VM::MethodFrame < ::SyntaxTree::YARV::VM::Frame
+ # @return [MethodFrame] a new instance of MethodFrame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#57
+ def initialize(iseq, nesting, parent, stack_index, _self, name, block); end
+
+ # Returns the value of attribute block.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#55
+ def block; end
+
+ # Returns the value of attribute name.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#55
+ def name; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#92
+class SyntaxTree::YARV::VM::NextError < ::SyntaxTree::YARV::VM::ThrownError; end
+
+# This is the main entrypoint for events firing in the VM, which allows
+# us to implement tracing.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#122
+class SyntaxTree::YARV::VM::NullEvents
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#123
+ def publish_frame_change(frame); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#126
+ def publish_instruction(iseq, insn); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#129
+ def publish_stack_change(stack); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#132
+ def publish_tracepoint(event); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#70
+class SyntaxTree::YARV::VM::RescueFrame < ::SyntaxTree::YARV::VM::Frame
+ # @return [RescueFrame] a new instance of RescueFrame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#71
+ def initialize(iseq, parent, stack_index); end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#86
+class SyntaxTree::YARV::VM::ReturnError < ::SyntaxTree::YARV::VM::ThrownError; end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#541
+SyntaxTree::YARV::VM::SOEXT = T.let(T.unsafe(nil), String)
+
+# This is a simple implementation of tracing that prints to STDOUT.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#137
+class SyntaxTree::YARV::VM::STDOUTEvents
+ # @return [STDOUTEvents] a new instance of STDOUTEvents
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#140
+ def initialize; end
+
+ # Returns the value of attribute disassembler.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#138
+ def disassembler; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#144
+ def publish_frame_change(frame); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#148
+ def publish_instruction(iseq, insn); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#153
+ def publish_stack_change(stack); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#157
+ def publish_tracepoint(event); end
+end
+
+# This represents the global VM stack. It effectively is an array, but
+# wraps mutating functions with instrumentation.
+#
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#164
+class SyntaxTree::YARV::VM::Stack
+ # @return [Stack] a new instance of Stack
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#167
+ def initialize(events); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#196
+ def [](*_arg0, **_arg1, &_arg2); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#200
+ def []=(*_arg0, **_arg1, &_arg2); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#172
+ def concat(*_arg0, **_arg1, &_arg2); end
+
+ # Returns the value of attribute events.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#165
+ def events; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#176
+ def last; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#180
+ def length; end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#188
+ def pop(*_arg0, **_arg1, &_arg2); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#184
+ def push(*_arg0, **_arg1, &_arg2); end
+
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#192
+ def slice!(*_arg0, **_arg1, &_arg2); end
+
+ # Returns the value of attribute values.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#165
+ def values; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#76
+class SyntaxTree::YARV::VM::ThrownError < ::StandardError
+ # @return [ThrownError] a new instance of ThrownError
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#79
+ def initialize(value, backtrace); end
+
+ # Returns the value of attribute value.
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#77
+ def value; end
+end
+
+# source://syntax_tree//lib/syntax_tree/yarv/vm.rb#42
+class SyntaxTree::YARV::VM::TopFrame < ::SyntaxTree::YARV::VM::Frame
+ # @return [TopFrame] a new instance of TopFrame
+ #
+ # source://syntax_tree//lib/syntax_tree/yarv/vm.rb#43
+ def initialize(iseq); end
+end
+
+# Yield represents using the +yield+ keyword with arguments.
+#
+# yield value
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12273
+class SyntaxTree::YieldNode < ::SyntaxTree::Node
+ # @return [YieldNode] a new instance of YieldNode
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12280
+ def initialize(arguments:, location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12334
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12286
+ def accept(visitor); end
+
+ # [nil | Args | Paren] the arguments passed to the yield
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12275
+ def arguments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12290
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12278
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12294
+ def copy(arguments: T.unsafe(nil), location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12290
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12307
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12311
+ def format(q); end
+end
+
+# ZSuper represents the bare +super+ keyword with no arguments.
+#
+# super
+#
+# source://syntax_tree//lib/syntax_tree/node.rb#12343
+class SyntaxTree::ZSuper < ::SyntaxTree::Node
+ # @return [ZSuper] a new instance of ZSuper
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12347
+ def initialize(location:); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12377
+ def ===(other); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12352
+ def accept(visitor); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12356
+ def child_nodes; end
+
+ # [Array[ Comment | EmbDoc ]] the comments attached to this node
+ #
+ # source://syntax_tree//lib/syntax_tree/node.rb#12345
+ def comments; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12360
+ def copy(location: T.unsafe(nil)); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12356
+ def deconstruct; end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12369
+ def deconstruct_keys(_keys); end
+
+ # source://syntax_tree//lib/syntax_tree/node.rb#12373
+ def format(q); end
+end
diff --git a/2023/sorbet/rbi/gems/tapioca@0.11.14.rbi b/2023/sorbet/rbi/gems/tapioca@0.11.14.rbi
new file mode 100644
index 0000000..ad8c418
--- /dev/null
+++ b/2023/sorbet/rbi/gems/tapioca@0.11.14.rbi
@@ -0,0 +1,3502 @@
+# typed: false
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `tapioca` gem.
+# Please instead update this file by running `bin/tapioca gem tapioca`.
+
+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
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# 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.6/lib/rbi/model.rb#119
+ sig do
+ params(
+ loc: T.nilable(::RBI::Loc),
+ comments: T::Array[::RBI::Comment],
+ block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+ ).void
+ end
+ def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+ # source://rbi/0.1.6/lib/rbi/model.rb#126
+ sig { params(node: ::RBI::Node).void }
+ def <<(node); end
+
+ # source://rbi/0.1.6/lib/rbi/printer.rb#226
+ sig { override.params(v: ::RBI::Printer).void }
+ def accept_printer(v); end
+
+ # source://rbi/0.1.6/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.6/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,
+ superclass_name: T.nilable(::String),
+ block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
+ ).returns(::RBI::Scope)
+ 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#89
+ sig do
+ params(
+ name: ::String,
+ parameters: T::Array[::RBI::TypedParam],
+ return_type: ::String,
+ class_method: T::Boolean,
+ visibility: ::RBI::Visibility,
+ comments: T::Array[::RBI::Comment]
+ ).void
+ 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)); 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,
+ type: ::String,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).void
+ 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.6/lib/rbi/rewriters/deannotate.rb#41
+ sig { params(annotation: ::String).void }
+ def deannotate!(annotation); end
+
+ # source://rbi/0.1.6/lib/rbi/model.rb#132
+ sig { returns(T::Boolean) }
+ def empty?; end
+
+ # source://rbi/0.1.6/lib/rbi/rewriters/group_nodes.rb#38
+ sig { void }
+ def group_nodes!; end
+
+ # source://rbi/0.1.6/lib/rbi/index.rb#68
+ sig { returns(::RBI::Index) }
+ def index; end
+
+ # source://rbi/0.1.6/lib/rbi/rewriters/merge_trees.rb#324
+ sig do
+ params(
+ other: ::RBI::Tree,
+ left_name: ::String,
+ right_name: ::String,
+ keep: ::RBI::Rewriters::Merge::Keep
+ ).returns(::RBI::MergeTree)
+ end
+ def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+ # source://rbi/0.1.6/lib/rbi/rewriters/nest_non_public_methods.rb#46
+ sig { void }
+ def nest_non_public_methods!; end
+
+ # source://rbi/0.1.6/lib/rbi/rewriters/nest_singleton_methods.rb#36
+ sig { void }
+ def nest_singleton_methods!; end
+
+ # source://rbi/0.1.6/lib/rbi/model.rb#110
+ sig { returns(T::Array[::RBI::Node]) }
+ def nodes; end
+
+ # source://rbi/0.1.6/lib/rbi/printer.rb#233
+ sig { override.returns(T::Boolean) }
+ def oneline?; end
+
+ # source://rbi/0.1.6/lib/rbi/rewriters/sort_nodes.rb#119
+ sig { void }
+ def sort_nodes!; end
+
+ private
+
+ # source://tapioca//lib/tapioca/rbi_ext/model.rb#116
+ sig { params(node: ::RBI::Node).returns(::RBI::Node) }
+ def create_node(node); end
+
+ # source://tapioca//lib/tapioca/rbi_ext/model.rb#111
+ sig { returns(T::Hash[::String, ::RBI::Node]) }
+ def nodes_cache; end
+end
+
+# source://tapioca//lib/tapioca/rbi_ext/model.rb#126
+class RBI::TypedParam < ::T::Struct
+ const :param, ::RBI::Param
+ const :type, ::String
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/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#53
+ 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), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#37
+ def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end
+end
+
+# This module intercepts calls to generic type instantiations and type variable definitions.
+# Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
+# to look up the original call details when we are trying to do code generation.
+#
+# 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#53
+ 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), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#37
+ def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: 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
+
+class T::Private::Methods::Declaration < ::Struct
+ def bind; end
+ def bind=(_); end
+ def checked; end
+ def checked=(_); end
+ def finalized; end
+ def finalized=(_); end
+ def mod; end
+ def mod=(_); end
+ def mode; end
+ def mode=(_); end
+ def on_failure; end
+ def on_failure=(_); end
+ def override_allow_incompatible; end
+ def override_allow_incompatible=(_); end
+ def params; end
+ def params=(_); end
+ def raw; end
+ def raw=(_); end
+ def returns; end
+ def returns=(_); end
+ def type_parameters; end
+ def type_parameters=(_); end
+
+ class << self
+ def [](*_arg0); end
+ def inspect; end
+ def keyword_init?; end
+ def members; end
+ def new(*_arg0); end
+ end
+end
+
+class T::Private::Methods::DeclarationBlock < ::Struct
+ def blk; end
+ def blk=(_); end
+ def final; end
+ def final=(_); end
+ def loc; end
+ def loc=(_); end
+ def mod; end
+ def mod=(_); end
+ def raw; end
+ def raw=(_); end
+
+ class << self
+ def [](*_arg0); end
+ def inspect; end
+ def keyword_init?; end
+ def members; end
+ def new(*_arg0); end
+ 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#79
+ def name; end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#74
+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#79
+ 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#99
+module T::Utils::Private
+ class << self
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#101
+ 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#100
+module T::Utils::Private::PrivateCoercePatch
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#101
+ 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#19
+ sig do
+ type_parameters(:Result)
+ .params(
+ blk: T.proc.returns(T.type_parameter(:Result))
+ ).returns(T.type_parameter(:Result))
+ end
+ def silence_warnings(&blk); end
+ end
+end
+
+# source://tapioca//lib/tapioca.rb#37
+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(
+ exclude: T::Array[::String],
+ blk: T.proc.returns(T.type_parameter(:Result))
+ ).returns(T.type_parameter(:Result))
+ end
+ def override_require_false(exclude:, &blk); end
+ end
+end
+
+# source://tapioca//lib/tapioca.rb#60
+Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#59
+Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#58
+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#355
+ def __print_version; end
+
+ # source://tapioca//lib/tapioca/cli.rb#337
+ def annotations; end
+
+ # source://tapioca//lib/tapioca/cli.rb#309
+ def check_shims; end
+
+ # source://tapioca//lib/tapioca/cli.rb#46
+ def configure; end
+
+ # source://tapioca//lib/tapioca/cli.rb#138
+ def dsl(*constant_or_paths); end
+
+ # @raise [MalformattedArgumentError]
+ #
+ # source://tapioca//lib/tapioca/cli.rb#253
+ 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#369
+ def print_init_next_steps; end
+
+ class << self
+ # source://tapioca//lib/tapioca/cli.rb#361
+ 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#31
+ sig do
+ params(
+ requested_constants: T::Array[::String],
+ requested_paths: T::Array[::Pathname],
+ outpath: ::Pathname,
+ only: T::Array[::String],
+ exclude: T::Array[::String],
+ file_header: T::Boolean,
+ tapioca_path: ::String,
+ quiet: T::Boolean,
+ verbose: T::Boolean,
+ number_of_workers: T.nilable(::Integer),
+ auto_strictness: T::Boolean,
+ gem_dir: ::String,
+ rbi_formatter: ::Tapioca::RBIFormatter,
+ app_root: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ end
+ def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+ private
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#94
+ sig { returns(T::Array[::String]) }
+ def all_requested_constants; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#284
+ 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#208
+ sig do
+ params(
+ constant_name: ::String,
+ rbi: ::RBI::File,
+ outpath: ::Pathname,
+ quiet: T::Boolean
+ ).returns(T.nilable(::Pathname))
+ 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#146
+ 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#169
+ 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#344
+ sig { returns(T::Array[::String]) }
+ def constants_from_requested_paths; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#117
+ sig { returns(::Tapioca::Dsl::Pipeline) }
+ def create_pipeline; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#247
+ sig { params(constant_name: ::String).returns(::Pathname) }
+ def dsl_rbi_filename(constant_name); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#132
+ 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#339
+ sig { params(constant: ::String).returns(::String) }
+ def generate_command_for(constant); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#70
+ 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#107
+ sig { void }
+ def load_application; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#226
+ sig { params(dir: ::Pathname).void }
+ def perform_dsl_verification(dir); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#102
+ sig { returns(::Tapioca::Dsl::Pipeline) }
+ def pipeline; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#235
+ sig { params(files: T::Set[::Pathname]).void }
+ def purge_stale_dsl_rbi_files(files); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#334
+ sig { params(constant: ::String).returns(::String) }
+ def rbi_filename_for(constant); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#315
+ sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
+ def rbi_files_in(path); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#293
+ 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#188
+ 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#322
+ sig { params(class_name: ::String).returns(::String) }
+ def underscore(class_name); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_dsl.rb#252
+ 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],
+ exclude: T::Array[::String],
+ include_dependencies: T::Boolean,
+ prerequire: T.nilable(::String),
+ postrequire: ::String,
+ typed_overrides: T::Hash[::String, ::String],
+ outpath: ::Pathname,
+ file_header: T::Boolean,
+ include_doc: T::Boolean,
+ include_loc: T::Boolean,
+ include_exported_rbis: T::Boolean,
+ number_of_workers: T.nilable(::Integer),
+ auto_strictness: T::Boolean,
+ dsl_dir: ::String,
+ rbi_formatter: ::Tapioca::RBIFormatter,
+ halt_upon_load_error: T::Boolean
+ ).void
+ end
+ def initialize(gem_names:, exclude:, include_dependencies:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+ private
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#221
+ sig { returns(T::Array[::String]) }
+ def added_rbis; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#282
+ 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#216
+ sig { params(gem_name: ::String).returns(::Pathname) }
+ def existing_rbi(gem_name); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#264
+ sig { returns(T::Hash[::String, ::String]) }
+ def existing_rbis; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#228
+ sig { params(gem_name: ::String).returns(::Pathname) }
+ def expected_rbi(gem_name); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#270
+ 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,
+ dependencies: T::Array[::Tapioca::Gemfile::GemSpec]
+ ).returns(T::Array[::Tapioca::Gemfile::GemSpec])
+ end
+ def gem_dependencies(gem, dependencies = T.unsafe(nil)); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#233
+ sig { params(gem_name: ::String).returns(T::Boolean) }
+ def gem_rbi_exists?(gem_name); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#277
+ 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#287
+ 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#258
+ sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
+ def move(old_filename, new_filename); end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#168
+ sig { void }
+ def perform_additions; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#141
+ sig { void }
+ def perform_removals; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#211
+ sig { returns(T::Array[::String]) }
+ def removed_rbis; end
+
+ # source://tapioca//lib/tapioca/commands/abstract_gem.rb#238
+ 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],
+ auth: T.nilable(::String),
+ netrc_file: T.nilable(::String),
+ central_repo_index_path: ::String,
+ typed_overrides: T::Hash[::String, ::String]
+ ).void
+ end
+ def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end
+
+ private
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#193
+ sig { params(name: ::String, content: ::String).returns(::String) }
+ def add_header(name, content); end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#213
+ 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_name: ::String).void }
+ def fetch_annotation(repo_uris, gem_name); end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#113
+ sig { params(gem_names: T::Array[::String]).returns(T::Array[::String]) }
+ def fetch_annotations(gem_names); end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#152
+ 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#169
+ 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#161
+ 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#50
+ sig { returns(T::Array[::String]) }
+ def list_gemfile_gems; end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#225
+ 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[::String]).void }
+ def remove_expired_annotations(project_gems); end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#252
+ sig { returns(T::Hash[::String, T.nilable(::String)]) }
+ def repo_tokens; end
+
+ # source://tapioca//lib/tapioca/commands/annotations.rb#280
+ 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#264
+ 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,
+ dsl_rbi_dir: ::String,
+ annotations_rbi_dir: ::String,
+ shim_rbi_dir: ::String,
+ todo_rbi_file: ::String,
+ payload: T::Boolean,
+ number_of_workers: T.nilable(::Integer)
+ ).void
+ end
+ def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end
+
+ 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
+ include ::Thor::Shell
+ include ::Tapioca::CliHelper
+ extend ::Thor::Base::ClassMethods
+ extend ::Thor::Invocation::ClassMethods
+
+ abstract!
+
+ # source://tapioca//lib/tapioca/commands/command.rb#20
+ sig { void }
+ def initialize; end
+
+ # source://thor/1.3.0/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),
+ content: ::String,
+ force: T::Boolean,
+ skip: T::Boolean,
+ verbose: T::Boolean
+ ).void
+ 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#151
+ sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
+ def build_error(msg); end
+
+ # source://tapioca//lib/tapioca/helpers/config_helper.rb#176
+ 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
+ ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+ 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#194
+ sig do
+ params(
+ options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
+ ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+ 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],
+ config_key: ::String,
+ config_options: T::Hash[T.untyped, T.untyped]
+ ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
+ end
+ def validate_config_options(command_options, config_key, config_options); end
+end
+
+# source://tapioca//lib/tapioca/helpers/config_helper.rb#146
+class Tapioca::ConfigHelper::ConfigError < ::T::Struct
+ const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://tapioca//lib/tapioca/helpers/config_helper.rb#141
+class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
+ const :message, ::String
+ const :colors, T::Array[::Symbol]
+
+ class << self
+ # source://sorbet-runtime/0.5.11162/lib/types/struct.rb#13
+ def inherited(s); end
+ end
+end
+
+# source://tapioca//lib/tapioca.rb#44
+Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#40
+Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#56
+Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#41
+Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#46
+Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
+
+# source://tapioca//lib/tapioca.rb#38
+Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#39
+Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/rbi_formatter.rb#29
+Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
+
+# source://tapioca//lib/tapioca.rb#55
+Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://tapioca//lib/tapioca.rb#42
+Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#43
+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
+ include ::Tapioca::RBIHelper
+ include ::Tapioca::Runtime::AttachedClassOf
+ include ::Tapioca::Runtime::Reflection
+ extend ::Tapioca::Runtime::AttachedClassOf
+ extend ::Tapioca::Runtime::Reflection
+
+ abstract!
+
+ ConstantType = type_member { { upper: Module } }
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#64
+ sig { params(pipeline: ::Tapioca::Dsl::Pipeline, root: ::RBI::Tree, constant: ConstantType).void }
+ def initialize(pipeline, root, constant); end
+
+ # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+ #
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#81
+ sig { params(error: ::String).void }
+ def add_error(error); end
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#72
+ 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#77
+ sig { abstract.void }
+ def decorate; end
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#23
+ sig { returns(::RBI::Tree) }
+ def root; end
+
+ private
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#130
+ 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#166
+ 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#120
+ 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#94
+ 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#34
+ sig { abstract.returns(T::Enumerable[::Module]) }
+ def gather_constants; end
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#29
+ sig { params(constant: ::Module).returns(T::Boolean) }
+ def handles?(constant); end
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#37
+ sig { returns(T::Set[::Module]) }
+ def processable_constants; end
+
+ private
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#47
+ sig { returns(T::Enumerable[T::Class[T.anything]]) }
+ def all_classes; end
+
+ # source://tapioca//lib/tapioca/dsl/compiler.rb#55
+ 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
+# `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
+# can be referred to by just using the class name, or they live in
+# 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#34
+ sig do
+ params(
+ requested_constants: T::Array[::Module],
+ requested_paths: T::Array[::Pathname],
+ requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+ excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+ error_handler: T.proc.params(error: ::String).void,
+ number_of_workers: T.nilable(::Integer)
+ ).void
+ 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), number_of_workers: 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#93
+ sig { params(error: ::String).void }
+ def add_error(error); end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#98
+ sig { params(compiler_name: ::String).returns(T::Boolean) }
+ def compiler_enabled?(compiler_name); end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#107
+ sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+ def compilers; end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#19
+ sig { returns(T.proc.params(error: ::String).void) }
+ def error_handler; end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#22
+ 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#58
+ sig do
+ type_parameters(:T)
+ .params(
+ blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T))
+ ).returns(T::Array[T.type_parameter(:T)])
+ end
+ def run(&blk); end
+
+ private
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#199
+ sig { void }
+ def abort_if_pending_migrations!; end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#144
+ 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#124
+ sig do
+ params(
+ requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+ excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
+ ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
+ end
+ def gather_active_compilers(requested_compilers, excluded_compilers); end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#132
+ sig do
+ params(
+ requested_constants: T::Array[::Module],
+ requested_paths: T::Array[::Pathname]
+ ).returns(T::Set[::Module])
+ end
+ def gather_constants(requested_constants, requested_paths); end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#173
+ sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
+ def rbi_for_constant(constant); end
+
+ # source://tapioca//lib/tapioca/dsl/pipeline.rb#192
+ 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(
+ block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
+ ).returns(T::Array[T.type_parameter(:T)])
+ end
+ def run_in_parallel(&block); end
+
+ 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
+ include ::Tapioca::Runtime::AttachedClassOf
+ include ::Tapioca::Runtime::Reflection
+
+ private
+
+ # source://tapioca//lib/tapioca/gem/listeners/methods.rb#35
+ sig do
+ params(
+ tree: ::RBI::Tree,
+ module_name: ::String,
+ mod: ::Module,
+ for_visibility: T::Array[::Symbol],
+ attached_class: T.nilable(::Module)
+ ).void
+ 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,
+ symbol_name: ::String,
+ constant: ::Module,
+ method: T.nilable(::UnboundMethod),
+ visibility: ::RBI::Visibility
+ ).void
+ 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#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
+
+ # Check whether the method is defined by the constant.
+ #
+ # In most cases, it works to check that the constant is the method owner. However,
+ # in the case that a method is also defined in a module prepended to the constant, it
+ # will be owned by the prepended module, not the constant.
+ #
+ # 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,
+ constant: ::Module,
+ mods: T::Array[::Module],
+ mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+ ).void
+ 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,
+ mixin: ::Module,
+ mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+ ).returns(T::Boolean)
+ 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
+ private
+
+ # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#32
+ sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+ def ignore?(event); end
+
+ # source://tapioca//lib/tapioca/gem/listeners/sorbet_props.rb#13
+ 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
+ include ::Tapioca::SorbetHelper
+ include ::Tapioca::RBIHelper
+
+ 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,
+ constant: ::Module,
+ method: ::UnboundMethod,
+ node: ::RBI::Method,
+ signature: T.untyped,
+ parameters: T::Array[[::Symbol, ::String]]
+ ).void
+ 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#17
+ sig { params(gem: ::Tapioca::Gemfile::GemSpec, include_doc: T::Boolean, include_loc: T::Boolean).void }
+ def initialize(gem, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#48
+ sig { returns(::RBI::Tree) }
+ def compile; end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#119
+ sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
+ def constant_in_gem?(name); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#14
+ sig { returns(::Tapioca::Gemfile::GemSpec) }
+ def gem; end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#137
+ sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+ def method_in_gem?(method); end
+
+ # Helpers
+ #
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#147
+ sig { params(constant: ::Module).returns(T.nilable(::String)) }
+ def name_of(constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#71
+ sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
+ def push_const(symbol, constant, node); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#61
+ sig { params(symbol: ::String, constant: ::BasicObject).void }
+ def push_constant(symbol, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#66
+ sig { params(symbol: ::String, constant: ::Module).void }
+ def push_foreign_constant(symbol, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#85
+ 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#99
+ sig do
+ params(
+ symbol: ::String,
+ constant: ::Module,
+ method: ::UnboundMethod,
+ node: ::RBI::Method,
+ signature: T.untyped,
+ parameters: T::Array[[::Symbol, ::String]]
+ ).void
+ end
+ def push_method(symbol, constant, method, node, signature, parameters); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#78
+ 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#56
+ sig { params(symbol: ::String).void }
+ def push_symbol(symbol); end
+
+ # Constants and properties filtering
+ #
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#106
+ sig { params(symbol_name: ::String).returns(T::Boolean) }
+ def symbol_in_payload?(symbol_name); end
+
+ private
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#441
+ sig { params(name: ::String).void }
+ def add_to_alias_namespace(name); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#446
+ sig { params(name: ::String).returns(T::Boolean) }
+ def alias_namespaced?(name); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#244
+ sig { params(name: ::String, constant: ::Module).void }
+ def compile_alias(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#230
+ sig { params(symbol: ::String, constant: ::BasicObject).void }
+ def compile_constant(symbol, constant); end
+
+ # Compiling
+ #
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#219
+ sig { params(symbol: ::String, constant: ::Module).void }
+ def compile_foreign_constant(symbol, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#300
+ sig { params(name: ::String, constant: ::Module).void }
+ def compile_module(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#265
+ sig { params(name: ::String, value: ::BasicObject).void }
+ def compile_object(name, value); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#311
+ sig { params(name: ::String, constant: ::Module).returns(::RBI::Scope) }
+ def compile_scope(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#325
+ sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
+ def compile_superclass(constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#422
+ 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#177
+ sig { params(event: ::Tapioca::Gem::Event).void }
+ def dispatch(event); end
+
+ # Helpers
+ #
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#465
+ sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
+ def generic_name_of(constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#434
+ sig { params(constant: ::Module).returns(T::Set[::String]) }
+ def get_file_candidates(constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#162
+ sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+ def load_bootstrap_symbols(gem); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#481
+ 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#172
+ sig { returns(::Tapioca::Gem::Event) }
+ def next_event; end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#200
+ sig { params(event: ::Tapioca::Gem::ConstantFound).void }
+ def on_constant(event); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#212
+ sig { params(event: ::Tapioca::Gem::NodeAdded).void }
+ def on_node(event); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#191
+ sig { params(event: ::Tapioca::Gem::SymbolFound).void }
+ def on_symbol(event); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#453
+ sig { params(name: ::String).void }
+ def seen!(name); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#458
+ sig { params(name: ::String).returns(T::Boolean) }
+ def seen?(name); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#393
+ sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+ def skip_alias?(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#381
+ sig { params(name: ::String, constant: T.anything).returns(T::Boolean) }
+ def skip_constant?(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#409
+ sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+ def skip_foreign_constant?(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#414
+ sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+ def skip_module?(name, constant); end
+
+ # source://tapioca//lib/tapioca/gem/pipeline.rb#401
+ 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#376
+ sig { params(name: ::String).returns(T::Boolean) }
+ def skip_symbol?(name); end
+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#116
+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/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#190
+ sig { returns(T::Boolean) }
+ def export_rbi_files?; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#185
+ sig { returns(T::Array[::String]) }
+ def exported_rbi_files; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#195
+ 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#207
+ 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#218
+ sig { returns(T::Array[::Pathname]) }
+ def collect_files; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#233
+ sig { returns(T.nilable(T::Boolean)) }
+ def default_gem?; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#292
+ sig { returns(T::Boolean) }
+ def gem_ignored?; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#271
+ sig { params(path: ::String).returns(T::Boolean) }
+ def has_parent_gemspec?(path); end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#238
+ sig { returns(::Regexp) }
+ def require_paths_prefix_matcher; end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#250
+ sig { params(file: ::String).returns(::Pathname) }
+ def resolve_to_ruby_lib_dir(file); end
+
+ # source://tapioca//lib/tapioca/gemfile.rb#264
+ 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/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,
+ eager_load: T::Boolean,
+ app_root: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ 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#81
+ 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,
+ eager_load: T::Boolean,
+ app_root: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ end
+ def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+ 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,
+ prerequire: T.nilable(::String),
+ postrequire: ::String,
+ default_command: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ 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,
+ prerequire: T.nilable(::String),
+ postrequire: ::String,
+ default_command: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ end
+ def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
+ end
+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
+ include ::Thor::Shell
+ include ::Tapioca::CliHelper
+ include ::Tapioca::GemHelper
+ extend ::Thor::Base::ClassMethods
+ extend ::Thor::Invocation::ClassMethods
+
+ abstract!
+
+ # @abstract
+ #
+ # source://tapioca//lib/tapioca/loaders/loader.rb#17
+ sig { abstract.void }
+ def load; end
+
+ private
+
+ # Rails 7.2 renamed `eager_load_paths` to `all_eager_load_paths`, which maintains the same original functionality.
+ # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
+ # engine paths. The following commit is the change:
+ # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
+ #
+ # @param engine [T.class_of(Rails::Engine)]
+ # @return [Array]
+ #
+ # source://sorbet-runtime/0.5.11162/lib/types/private/methods/_methods.rb#254
+ def eager_load_paths(*args, **_arg1, &blk); end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#198
+ sig { void }
+ def eager_load_rails_app; end
+
+ # @return [Array]
+ #
+ # source://tapioca//lib/tapioca/loaders/loader.rb#169
+ def engines; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#29
+ sig do
+ params(
+ gemfile: ::Tapioca::Gemfile,
+ initialize_file: T.nilable(::String),
+ require_file: T.nilable(::String),
+ halt_upon_load_error: T::Boolean
+ ).void
+ end
+ def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#127
+ sig { void }
+ def load_engines_in_classic_mode; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#105
+ sig { void }
+ def load_engines_in_zeitwerk_mode; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#49
+ sig do
+ params(
+ environment_load: T::Boolean,
+ eager_load: T::Boolean,
+ app_root: ::String,
+ halt_upon_load_error: T::Boolean
+ ).void
+ 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#80
+ sig { void }
+ def load_rails_engines; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#219
+ sig { params(file: T.nilable(::String)).void }
+ def require_helper(file); end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#94
+ def run_initializers; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#183
+ sig { params(path: ::String).void }
+ def safe_require(path); end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#190
+ sig { void }
+ def silence_deprecations; end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#152
+ sig { params(blk: T.proc.void).void }
+ def with_rails_application(&blk); end
+
+ # source://tapioca//lib/tapioca/loaders/loader.rb#145
+ 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,
+ shim_rbi_dir: ::String,
+ todo_rbi_file: ::String
+ ).returns(T::Hash[::String, T::Array[::RBI::Node]])
+ 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,
+ gem_dir: ::String,
+ dsl_dir: ::String,
+ auto_strictness: T::Boolean,
+ gems: T::Array[::Tapioca::Gemfile::GemSpec],
+ compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]
+ ).void
+ end
+ def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end
+
+ private
+
+ # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#209
+ 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#214
+ 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#224
+ 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#234
+ sig do
+ params(
+ nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
+ ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)])
+ end
+ def extract_nodes_with_sigs(nodes); end
+
+ # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#202
+ sig do
+ params(
+ nodes: T::Array[::RBI::Node],
+ shim_rbi_dir: ::String,
+ todo_rbi_file: ::String
+ ).returns(T::Array[::RBI::Node])
+ end
+ def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end
+
+ # source://tapioca//lib/tapioca/helpers/rbi_files_helper.rb#266
+ 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#239
+ 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#22
+ 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#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#100
+ sig { params(name: ::String).returns(T::Boolean) }
+ def valid_method_name?(name); end
+
+ # source://tapioca//lib/tapioca/helpers/rbi_helper.rb#114
+ 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,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).returns(::String)
+ end
+ def serialize_type_variable(type, variance, fixed, upper, lower); end
+ 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
+# older than 3.2. Because the Class#attached_object method is not
+# 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]
+ #
+ # 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]
+ #
+ # 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]
+ #
+ # 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]
+ #
+ # 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]
+ #
+ # 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
+
+# This class is responsible for storing and looking up information related to generic types.
+#
+# The class stores 2 different kinds of data, in two separate lookup tables:
+# 1. a lookup of generic type instances by name: `@generic_instances`
+# 2. a lookup of type variable serializer by constant and type variable
+# instance: `@type_variables`
+#
+# By storing the above data, we can cheaply query each constant against this registry
+# to see if it declares any generic type variables. This becomes a simple lookup in the
+# `@type_variables` hash table with the given constant.
+#
+# If there is no entry, then we can cheaply know that we can skip generic type
+# information generation for this type.
+#
+# 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
+
+ # This method is responsible for building the name of the instantiated concrete type
+ # and cloning the given constant so that we can return a type that is the same
+ # as the current type but is a different instance and has a different name method.
+ #
+ # We cache those cloned instances by their name in `@generic_instances`, so that
+ # we don't keep instantiating a new type every single time it is referenced.
+ # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+ # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+ # 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
+
+ # This method is called from intercepted calls to `type_member` and `type_template`.
+ # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+ # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+ #
+ # This method creates a `String` with that data and stores it in the
+ # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+ #
+ # 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 { params(obj: T.untyped).returns(T::Boolean) }
+ def valid?(obj); end
+end
+
+module Tapioca::Runtime::Reflection
+ include ::Tapioca::Runtime::AttachedClassOf
+ extend ::Tapioca::Runtime::AttachedClassOf
+ extend ::Tapioca::Runtime::Reflection
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#196
+ 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
+
+ # Returns an array with all classes that are < than the supplied class.
+ #
+ # class C; end
+ # descendants_of(C) # => []
+ #
+ # class B < C; end
+ # descendants_of(C) # => [B]
+ #
+ # class A < B; end
+ # descendants_of(C) # => [B, A]
+ #
+ # class D < C; end
+ # descendants_of(C) # => [B, A, D]
+ #
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#167
+ sig do
+ type_parameters(:U)
+ .params(
+ klass: T.all(T.type_parameter(:U), T::Class[T.anything])
+ ).returns(T::Array[T.type_parameter(:U)])
+ end
+ def descendants_of(klass); end
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#189
+ sig { params(constant: ::Module).returns(T::Set[::String]) }
+ def file_candidates_for(constant); end
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#202
+ 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#145
+ 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#140
+ 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 "". If none is found, it returns the location
+ # labeled "", which is the original call site.
+ #
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#179
+ sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) }
+ def resolve_loc(locations); end
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#207
+ sig { params(constant: ::Module).returns(T::Boolean) }
+ def sealed_module?(constant); 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#244
+ 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#255
+ sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+ def method_defined_by_forwardable_module?(method); end
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#230
+ sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
+ def methods_for(constant); end
+
+ # source://tapioca//lib/tapioca/runtime/reflection.rb#214
+ 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(
+ blk: T.proc.returns(T.type_parameter(:Return))
+ ).returns(T.type_parameter(:Return))
+ end
+ def with_trackers_enabled(&blk); end
+ 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(
+ block: T.proc.returns(T.type_parameter(:Result))
+ ).returns(T.type_parameter(:Result))
+ end
+ def with_disabled_exits(&block); end
+ 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
+# classes and modules are opened for definition. This is used to track
+# correspondence between classes/modules and files, as this information isn't
+# available in the ruby runtime without extra accounting.
+module Tapioca::Runtime::Trackers::ConstantDefinition
+ extend ::Tapioca::Runtime::Trackers::Tracker
+ extend ::Tapioca::Runtime::AttachedClassOf
+ 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
+
+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
+ ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+ end
+ def constants_with_mixin(mixin); end
+
+ # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#61
+ sig do
+ params(
+ mixin: ::Module,
+ mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+ constant: ::Module
+ ).returns(T.nilable(::String))
+ 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(
+ block: T.proc.returns(T.type_parameter(:Result))
+ ).returns(T.type_parameter(:Result))
+ end
+ def with_disabled_registration(&block); end
+
+ private
+
+ # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#76
+ sig do
+ params(
+ mixin: ::Module
+ ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+ end
+ def find_or_initialize_mixin_lookup(mixin); end
+
+ # source://tapioca//lib/tapioca/runtime/trackers/mixin.rb#68
+ sig do
+ params(
+ constant: ::Module,
+ mixin: ::Module,
+ mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+ location: ::String
+ ).void
+ end
+ def register_with_location(constant, mixin, mixin_type, location); end
+ end
+end
+
+class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
+ enums do
+ Prepend = new
+ Include = new
+ Extend = 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
+end
+
+# @abstract Subclasses must implement the `abstract` methods below.
+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#33
+Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#32
+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#34
+ sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
+ def sorbet(*sorbet_args); end
+
+ # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#39
+ sig { returns(::String) }
+ def sorbet_path; end
+
+ # source://tapioca//lib/tapioca/helpers/sorbet_helper.rb#46
+ 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]
+ #
+ # source://sorbet-runtime/0.5.11162/lib/types/private/methods/_methods.rb#254
+ def engines(*args, **_arg1, &blk); 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#35
+Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca.rb#34
+Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#137
+class Tapioca::TypeVariable < ::T::Types::TypeVariable
+ # @return [TypeVariable] a new instance of TypeVariable
+ #
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#138
+ def initialize(name, variance); end
+
+ # Returns the value of attribute name.
+ #
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#143
+ def name; end
+end
+
+# This is subclassing from `Module` so that instances of this type will be modules.
+# The reason why we want that is because that means those instances will automatically
+# 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#151
+class Tapioca::TypeVariableModule < ::Module
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#177
+ sig do
+ params(
+ context: ::Module,
+ type: ::Tapioca::TypeVariableModule::Type,
+ variance: ::Symbol,
+ fixed: T.untyped,
+ lower: T.untyped,
+ upper: T.untyped,
+ bounds_proc: T.nilable(T.proc.returns(T::Hash[::Symbol, T.untyped]))
+ ).void
+ end
+ def initialize(context, type, variance, fixed, lower, upper, bounds_proc); end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#218
+ sig { returns(::Tapioca::TypeVariable) }
+ def coerce_to_type_variable; end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#198
+ sig { returns(T::Boolean) }
+ def fixed?; end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#192
+ sig { returns(T.nilable(::String)) }
+ def name; end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#203
+ sig { returns(::String) }
+ def serialize; end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#163
+ sig { returns(::Tapioca::TypeVariableModule::Type) }
+ def type; end
+
+ private
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#238
+ sig { returns(T::Hash[::Symbol, T.untyped]) }
+ def bounds; end
+
+ # source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#228
+ sig do
+ params(
+ fixed: T.untyped,
+ lower: T.untyped,
+ upper: T.untyped
+ ).returns(T.proc.returns(T::Hash[::Symbol, T.untyped]))
+ end
+ def build_bounds_proc(fixed, lower, upper); end
+end
+
+# source://tapioca//lib/tapioca/sorbet_ext/generic_name_patch.rb#154
+class Tapioca::TypeVariableModule::Type < ::T::Enum
+ enums do
+ 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.12.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.12.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,
+ gem_version: T.nilable(::String),
+ path: ::String,
+ line_number: T.nilable(::String)
+ ).returns(::URI::Source)
+ end
+ def build(gem_name:, gem_version:, path:, line_number:); end
+ end
+end
+
+# source://tapioca//lib/tapioca/helpers/source_uri.rb#10
+URI::Source::COMPONENT = T.let(T.unsafe(nil), Array)
diff --git a/2023/sorbet/rbi/gems/thor@1.3.0.rbi b/2023/sorbet/rbi/gems/thor@1.3.0.rbi
new file mode 100644
index 0000000..f1a6cbe
--- /dev/null
+++ b/2023/sorbet/rbi/gems/thor@1.3.0.rbi
@@ -0,0 +1,4312 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `bin/tapioca gem thor`.
+
+# source://thor//lib/thor/shell/lcs_diff.rb#1
+module LCSDiff
+ protected
+
+ # Overwrite show_diff to show diff with colors if Diff::LCS is
+ # available.
+ #
+ # source://thor//lib/thor/shell/lcs_diff.rb#6
+ def show_diff(destination, content); end
+
+ private
+
+ # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+ # for diff.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/shell/lcs_diff.rb#37
+ def diff_lcs_loaded?; end
+
+ # source://thor//lib/thor/shell/lcs_diff.rb#21
+ def output_diff_line(diff); end
+end
+
+# source://thor//lib/thor/command.rb#1
+class Thor
+ include ::Thor::Base
+ include ::Thor::Invocation
+ include ::Thor::Shell
+ extend ::Thor::Base::ClassMethods
+ extend ::Thor::Invocation::ClassMethods
+
+ # source://thor//lib/thor.rb#652
+ def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ class << self
+ # Adds and declares option group for required at least one of options in the
+ # block of arguments. You can declare options as the outside of the block.
+ #
+ # If :for is given as option, it allows you to change the options from
+ # a previous defined command.
+ #
+ # ==== Parameters
+ # Array[Thor::Option.name]
+ # options:: :for is applied for previous defined command.
+ #
+ # ==== Examples
+ #
+ # at_least_one do
+ # option :one
+ # option :two
+ # end
+ #
+ # Or
+ #
+ # option :one
+ # option :two
+ # at_least_one :one, :two
+ #
+ # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+ # will be raised.
+ #
+ # You can use at_least_one and exclusive at the same time.
+ #
+ # exclusive do
+ # at_least_one do
+ # option :one
+ # option :two
+ # end
+ # end
+ #
+ # Then it is required either only one of "--one" or "--two".
+ #
+ # source://thor//lib/thor.rb#246
+ def at_least_one(*args, &block); end
+
+ # Extend check unknown options to accept a hash of conditions.
+ #
+ # === Parameters
+ # options: A hash containing :only and/or :except keys
+ #
+ # source://thor//lib/thor.rb#350
+ def check_unknown_options!(options = T.unsafe(nil)); end
+
+ # Overwrite check_unknown_options? to take subcommands and options into account.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor.rb#363
+ def check_unknown_options?(config); end
+
+ # Prints help information for the given command.
+ #
+ # ==== Parameters
+ # shell
+ # command_name
+ #
+ # source://thor//lib/thor.rb#258
+ def command_help(shell, command_name); end
+
+ # Sets the default command when thor is executed without an explicit command to be called.
+ #
+ # ==== Parameters
+ # meth:: name of the default command
+ #
+ # source://thor//lib/thor.rb#21
+ def default_command(meth = T.unsafe(nil)); end
+
+ # Sets the default command when thor is executed without an explicit command to be called.
+ #
+ # ==== Parameters
+ # meth:: name of the default command
+ #
+ # source://thor//lib/thor.rb#21
+ def default_task(meth = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/base.rb#26
+ def deprecation_warning(message); end
+
+ # Defines the usage and the description of the next command.
+ #
+ # ==== Parameters
+ # usage
+ # description
+ # options
+ #
+ # source://thor//lib/thor.rb#54
+ def desc(usage, description, options = T.unsafe(nil)); end
+
+ # Disable the check for required options for the given commands.
+ # This is useful if you have a command that does not need the required options
+ # to work, like help.
+ #
+ # ==== Parameters
+ # Symbol ...:: A list of commands that should be affected.
+ #
+ # source://thor//lib/thor.rb#434
+ def disable_required_check!(*command_names); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor.rb#438
+ def disable_required_check?(command); end
+
+ # Adds and declares option group for exclusive options in the
+ # block and arguments. You can declare options as the outside of the block.
+ #
+ # If :for is given as option, it allows you to change the options from
+ # a previous defined command.
+ #
+ # ==== Parameters
+ # Array[Thor::Option.name]
+ # options:: :for is applied for previous defined command.
+ #
+ # ==== Examples
+ #
+ # exclusive do
+ # option :one
+ # option :two
+ # end
+ #
+ # Or
+ #
+ # option :one
+ # option :two
+ # exclusive :one, :two
+ #
+ # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+ # will be raised.
+ #
+ # source://thor//lib/thor.rb#203
+ def exclusive(*args, &block); end
+
+ # Prints help information for this class.
+ #
+ # ==== Parameters
+ # shell
+ #
+ # source://thor//lib/thor.rb#288
+ def help(shell, subcommand = T.unsafe(nil)); end
+
+ # Defines the long description of the next command.
+ #
+ # Long description is by default indented, line-wrapped and repeated whitespace merged.
+ # In order to print long description verbatim, with indentation and spacing exactly
+ # as found in the code, use the +wrap+ option
+ #
+ # long_desc 'your very long description', wrap: false
+ #
+ # ==== Parameters
+ # long description
+ # options
+ #
+ # source://thor//lib/thor.rb#78
+ def long_desc(long_description, options = T.unsafe(nil)); end
+
+ # Maps an input to a command. If you define:
+ #
+ # map "-T" => "list"
+ #
+ # Running:
+ #
+ # thor -T
+ #
+ # Will invoke the list command.
+ #
+ # ==== Parameters
+ # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+ #
+ # source://thor//lib/thor.rb#101
+ def map(mappings = T.unsafe(nil), **kw); end
+
+ # Adds and declares option group for required at least one of options in the
+ # block of arguments. You can declare options as the outside of the block.
+ #
+ # If :for is given as option, it allows you to change the options from
+ # a previous defined command.
+ #
+ # ==== Parameters
+ # Array[Thor::Option.name]
+ # options:: :for is applied for previous defined command.
+ #
+ # ==== Examples
+ #
+ # at_least_one do
+ # option :one
+ # option :two
+ # end
+ #
+ # Or
+ #
+ # option :one
+ # option :two
+ # at_least_one :one, :two
+ #
+ # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+ # will be raised.
+ #
+ # You can use at_least_one and exclusive at the same time.
+ #
+ # exclusive do
+ # at_least_one do
+ # option :one
+ # option :two
+ # end
+ # end
+ #
+ # Then it is required either only one of "--one" or "--two".
+ #
+ # source://thor//lib/thor.rb#246
+ def method_at_least_one(*args, &block); end
+
+ # Adds and declares option group for exclusive options in the
+ # block and arguments. You can declare options as the outside of the block.
+ #
+ # If :for is given as option, it allows you to change the options from
+ # a previous defined command.
+ #
+ # ==== Parameters
+ # Array[Thor::Option.name]
+ # options:: :for is applied for previous defined command.
+ #
+ # ==== Examples
+ #
+ # exclusive do
+ # option :one
+ # option :two
+ # end
+ #
+ # Or
+ #
+ # option :one
+ # option :two
+ # exclusive :one, :two
+ #
+ # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+ # will be raised.
+ #
+ # source://thor//lib/thor.rb#203
+ def method_exclusive(*args, &block); end
+
+ # Adds an option to the set of method options. If :for is given as option,
+ # it allows you to change the options from a previous defined command.
+ #
+ # def previous_command
+ # # magic
+ # end
+ #
+ # method_option :foo, :for => :previous_command
+ #
+ # def next_command
+ # # magic
+ # end
+ #
+ # ==== Parameters
+ # name:: The name of the argument.
+ # options:: Described below.
+ #
+ # ==== Options
+ # :desc - Description for the argument.
+ # :required - If the argument is required or not.
+ # :default - Default value for this argument. It cannot be required and have default values.
+ # :aliases - Aliases for this option.
+ # :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+ # :banner - String to show on usage notes.
+ # :hide - If you want to hide this option from the help.
+ #
+ # source://thor//lib/thor.rb#163
+ def method_option(name, options = T.unsafe(nil)); end
+
+ # Declares the options for the next command to be declared.
+ #
+ # ==== Parameters
+ # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+ # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+ # or :required (string). If you give a value, the type of the value is used.
+ #
+ # source://thor//lib/thor.rb#129
+ def method_options(options = T.unsafe(nil)); end
+
+ # Adds an option to the set of method options. If :for is given as option,
+ # it allows you to change the options from a previous defined command.
+ #
+ # def previous_command
+ # # magic
+ # end
+ #
+ # method_option :foo, :for => :previous_command
+ #
+ # def next_command
+ # # magic
+ # end
+ #
+ # ==== Parameters
+ # name:: The name of the argument.
+ # options:: Described below.
+ #
+ # ==== Options
+ # :desc - Description for the argument.
+ # :required - If the argument is required or not.
+ # :default - Default value for this argument. It cannot be required and have default values.
+ # :aliases - Aliases for this option.
+ # :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+ # :banner - String to show on usage notes.
+ # :hide - If you want to hide this option from the help.
+ #
+ # source://thor//lib/thor.rb#163
+ def option(name, options = T.unsafe(nil)); end
+
+ # Declares the options for the next command to be declared.
+ #
+ # ==== Parameters
+ # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+ # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+ # or :required (string). If you give a value, the type of the value is used.
+ #
+ # source://thor//lib/thor.rb#129
+ def options(options = T.unsafe(nil)); end
+
+ # Allows for custom "Command" package naming.
+ #
+ # === Parameters
+ # name
+ # options
+ #
+ # source://thor//lib/thor.rb#12
+ def package_name(name, _ = T.unsafe(nil)); end
+
+ # Returns commands ready to be printed.
+ #
+ # source://thor//lib/thor.rb#309
+ def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # Returns commands ready to be printed.
+ #
+ # source://thor//lib/thor.rb#309
+ def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # Registers another Thor subclass as a command.
+ #
+ # ==== Parameters
+ # klass:: Thor subclass to register
+ # command:: Subcommand name to use
+ # usage:: Short usage for the subcommand
+ # description:: Description for the subcommand
+ #
+ # source://thor//lib/thor.rb#37
+ def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
+
+ # Stop parsing of options as soon as an unknown option or a regular
+ # argument is encountered. All remaining arguments are passed to the command.
+ # This is useful if you have a command that can receive arbitrary additional
+ # options, and where those additional options should not be handled by
+ # Thor.
+ #
+ # ==== Example
+ #
+ # To better understand how this is useful, let's consider a command that calls
+ # an external command. A user may want to pass arbitrary options and
+ # arguments to that command. The command itself also accepts some options,
+ # which should be handled by Thor.
+ #
+ # class_option "verbose", :type => :boolean
+ # stop_on_unknown_option! :exec
+ # check_unknown_options! :except => :exec
+ #
+ # desc "exec", "Run a shell command"
+ # def exec(*args)
+ # puts "diagnostic output" if options[:verbose]
+ # Kernel.exec(*args)
+ # end
+ #
+ # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+ # e.g.:
+ #
+ # $ thor exec --verbose echo foo
+ # diagnostic output
+ # foo
+ #
+ # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+ #
+ # $ thor exec echo --verbose foo
+ # --verbose foo
+ #
+ # ==== Parameters
+ # Symbol ...:: A list of commands that should be affected.
+ #
+ # source://thor//lib/thor.rb#420
+ def stop_on_unknown_option!(*command_names); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor.rb#424
+ def stop_on_unknown_option?(command); end
+
+ # source://thor//lib/thor.rb#329
+ def subcommand(subcommand, subcommand_class); end
+
+ # source://thor//lib/thor.rb#325
+ def subcommand_classes; end
+
+ # source://thor//lib/thor.rb#320
+ def subcommands; end
+
+ # source://thor//lib/thor.rb#329
+ def subtask(subcommand, subcommand_class); end
+
+ # source://thor//lib/thor.rb#320
+ def subtasks; end
+
+ # Prints help information for the given command.
+ #
+ # ==== Parameters
+ # shell
+ # command_name
+ #
+ # source://thor//lib/thor.rb#258
+ def task_help(shell, command_name); end
+
+ protected
+
+ # The banner for this class. You can customize it if you are invoking the
+ # thor class by another ways which is not the Thor::Runner. It receives
+ # the command that is going to be invoked and a boolean which indicates if
+ # the namespace should be displayed as arguments.
+ #
+ # source://thor//lib/thor.rb#535
+ def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # source://thor//lib/thor.rb#541
+ def baseclass; end
+
+ # source://thor//lib/thor.rb#549
+ def create_command(meth); end
+
+ # source://thor//lib/thor.rb#549
+ def create_task(meth); end
+
+ # help command has the required check disabled by default.
+ #
+ # source://thor//lib/thor.rb#467
+ def disable_required_check; end
+
+ # The method responsible for dispatching given the args.
+ #
+ # @yield [instance]
+ #
+ # source://thor//lib/thor.rb#494
+ def dispatch(meth, given_args, given_opts, config); end
+
+ # source://thor//lib/thor.rb#545
+ def dynamic_command_class; end
+
+ # this is the logic that takes the command name passed in by the user
+ # and determines whether it is an unambiguous substrings of a command or
+ # alias name.
+ #
+ # source://thor//lib/thor.rb#615
+ def find_command_possibilities(meth); end
+
+ # this is the logic that takes the command name passed in by the user
+ # and determines whether it is an unambiguous substrings of a command or
+ # alias name.
+ #
+ # source://thor//lib/thor.rb#615
+ def find_task_possibilities(meth); end
+
+ # source://thor//lib/thor.rb#575
+ def initialize_added; end
+
+ # Returns this class at least one of required options array set.
+ #
+ # ==== Returns
+ # Array[Array[Thor::Option.name]]
+ #
+ # source://thor//lib/thor.rb#458
+ def method_at_least_one_option_names; end
+
+ # Returns this class exclusive options array set.
+ #
+ # ==== Returns
+ # Array[Array[Thor::Option.name]]
+ #
+ # source://thor//lib/thor.rb#449
+ def method_exclusive_option_names; end
+
+ # receives a (possibly nil) command name and returns a name that is in
+ # the commands hash. In addition to normalizing aliases, this logic
+ # will determine if a shortened command is an unambiguous substring of
+ # a command or alias.
+ #
+ # +normalize_command_name+ also converts names like +animal-prison+
+ # into +animal_prison+.
+ #
+ # @raise [AmbiguousTaskError]
+ #
+ # source://thor//lib/thor.rb#594
+ def normalize_command_name(meth); end
+
+ # receives a (possibly nil) command name and returns a name that is in
+ # the commands hash. In addition to normalizing aliases, this logic
+ # will determine if a shortened command is an unambiguous substring of
+ # a command or alias.
+ #
+ # +normalize_command_name+ also converts names like +animal-prison+
+ # into +animal_prison+.
+ #
+ # @raise [AmbiguousTaskError]
+ #
+ # source://thor//lib/thor.rb#594
+ def normalize_task_name(meth); end
+
+ # source://thor//lib/thor.rb#482
+ def print_at_least_one_required_options(shell, command = T.unsafe(nil)); end
+
+ # source://thor//lib/thor.rb#471
+ def print_exclusive_options(shell, command = T.unsafe(nil)); end
+
+ # Retrieve the command name from given args.
+ #
+ # source://thor//lib/thor.rb#581
+ def retrieve_command_name(args); end
+
+ # Retrieve the command name from given args.
+ #
+ # source://thor//lib/thor.rb#581
+ def retrieve_task_name(args); end
+
+ # Sort the commands, lexicographically by default.
+ #
+ # Can be overridden in the subclass to change the display order of the
+ # commands.
+ #
+ # source://thor//lib/thor.rb#642
+ def sort_commands!(list); end
+
+ # source://thor//lib/thor.rb#462
+ def stop_on_unknown_option; end
+
+ # source://thor//lib/thor.rb#630
+ def subcommand_help(cmd); end
+
+ # source://thor//lib/thor.rb#630
+ def subtask_help(cmd); end
+ end
+end
+
+# source://thor//lib/thor/actions/empty_directory.rb#2
+module Thor::Actions
+ mixes_in_class_methods ::Thor::Actions::ClassMethods
+
+ # Extends initializer to add more configuration options.
+ #
+ # ==== Configuration
+ # behavior:: The actions default behavior. Can be :invoke or :revoke.
+ # It also accepts :force, :skip and :pretend to set the behavior
+ # and the respective option.
+ #
+ # destination_root:: The root directory needed for some actions.
+ #
+ # source://thor//lib/thor/actions.rb#72
+ def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+ # Wraps an action object and call it accordingly to the thor class behavior.
+ #
+ # source://thor//lib/thor/actions.rb#89
+ def action(instance); end
+
+ # Create a new file relative to the destination root with the given data,
+ # which is the return value of a block or a data string.
+ #
+ # ==== Parameters
+ # destination:: the relative path to the destination root.
+ # data:: the data to append to the file.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # create_file "lib/fun_party.rb" do
+ # hostname = ask("What is the virtual hostname I should use?")
+ # "vhost.name = #{hostname}"
+ # end
+ #
+ # create_file "config/apache.conf", "your apache config"
+ #
+ # source://thor//lib/thor/actions/create_file.rb#22
+ def add_file(destination, *args, &block); end
+
+ # Create a new file relative to the destination root from the given source.
+ #
+ # ==== Parameters
+ # destination:: the relative path to the destination root.
+ # source:: the relative path to the source root.
+ # config:: give :verbose => false to not log the status.
+ # :: give :symbolic => false for hard link.
+ #
+ # ==== Examples
+ #
+ # create_link "config/apache.conf", "/etc/apache.conf"
+ #
+ # source://thor//lib/thor/actions/create_link.rb#17
+ def add_link(destination, *args); end
+
+ # Append text to a file. Since it depends on insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # data:: the data to append to the file, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+ #
+ # append_to_file 'config/environments/test.rb' do
+ # 'config.gem "rspec"'
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#193
+ def append_file(path, *args, &block); end
+
+ # Append text to a file. Since it depends on insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # data:: the data to append to the file, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+ #
+ # append_to_file 'config/environments/test.rb' do
+ # 'config.gem "rspec"'
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#193
+ def append_to_file(path, *args, &block); end
+
+ # Loads an external file and execute it in the instance binding.
+ #
+ # ==== Parameters
+ # path:: The path to the file to execute. Can be a web address or
+ # a relative path from the source root.
+ #
+ # ==== Examples
+ #
+ # apply "http://gist.github.com/103208"
+ #
+ # apply "recipes/jquery.rb"
+ #
+ # source://thor//lib/thor/actions.rb#216
+ def apply(path, config = T.unsafe(nil)); end
+
+ # Returns the value of attribute behavior.
+ #
+ # source://thor//lib/thor/actions.rb#10
+ def behavior; end
+
+ # Sets the attribute behavior
+ #
+ # @param value the value to set the attribute behavior to.
+ #
+ # source://thor//lib/thor/actions.rb#10
+ def behavior=(_arg0); end
+
+ # Changes the mode of the given file or directory.
+ #
+ # ==== Parameters
+ # mode:: the file mode
+ # path:: the name of the file to change mode
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # chmod "script/server", 0755
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#146
+ def chmod(path, mode, config = T.unsafe(nil)); end
+
+ # Comment all lines matching a given regex. It will leave the space
+ # which existed before the beginning of the line in tact and will insert
+ # a single space after the comment hash.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # flag:: the regexp or string used to decide which lines to comment
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # comment_lines 'config/initializers/session_store.rb', /cookie_store/
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#310
+ def comment_lines(path, flag, *args); end
+
+ # ==== Examples
+ #
+ # copy_file "README", "doc/README"
+ #
+ # copy_file "doc/README"
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#21
+ def copy_file(source, *args, &block); end
+
+ # Create a new file relative to the destination root with the given data,
+ # which is the return value of a block or a data string.
+ #
+ # ==== Parameters
+ # destination:: the relative path to the destination root.
+ # data:: the data to append to the file.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # create_file "lib/fun_party.rb" do
+ # hostname = ask("What is the virtual hostname I should use?")
+ # "vhost.name = #{hostname}"
+ # end
+ #
+ # create_file "config/apache.conf", "your apache config"
+ #
+ # source://thor//lib/thor/actions/create_file.rb#22
+ def create_file(destination, *args, &block); end
+
+ # Create a new file relative to the destination root from the given source.
+ #
+ # ==== Parameters
+ # destination:: the relative path to the destination root.
+ # source:: the relative path to the source root.
+ # config:: give :verbose => false to not log the status.
+ # :: give :symbolic => false for hard link.
+ #
+ # ==== Examples
+ #
+ # create_link "config/apache.conf", "/etc/apache.conf"
+ #
+ # source://thor//lib/thor/actions/create_link.rb#17
+ def create_link(destination, *args); end
+
+ # Returns the root for this thor class (also aliased as destination root).
+ #
+ # source://thor//lib/thor/actions.rb#99
+ def destination_root; end
+
+ # Sets the root for this thor class. Relatives path are added to the
+ # directory where the script was invoked and expanded.
+ #
+ # source://thor//lib/thor/actions.rb#106
+ def destination_root=(root); end
+
+ # Copies recursively the files from source directory to root directory.
+ # If any of the files finishes with .tt, it's considered to be a template
+ # and is placed in the destination without the extension .tt. If any
+ # empty directory is found, it's copied and all .empty_directory files are
+ # ignored. If any file name is wrapped within % signs, the text within
+ # the % signs will be executed as a method and replaced with the returned
+ # value. Let's suppose a doc directory with the following files:
+ #
+ # doc/
+ # components/.empty_directory
+ # README
+ # rdoc.rb.tt
+ # %app_name%.rb
+ #
+ # When invoked as:
+ #
+ # directory "doc"
+ #
+ # It will create a doc directory in the destination with the following
+ # files (assuming that the `app_name` method returns the value "blog"):
+ #
+ # doc/
+ # components/
+ # README
+ # rdoc.rb
+ # blog.rb
+ #
+ # Encoded path note: Since Thor internals use Object#respond_to? to check if it can
+ # expand %something%, this `something` should be a public method in the class calling
+ # #directory. If a method is private, Thor stack raises PrivateMethodEncodedError.
+ #
+ # ==== Parameters
+ # source:: the relative path to the source root.
+ # destination:: the relative path to the destination root.
+ # config:: give :verbose => false to not log the status.
+ # If :recursive => false, does not look for paths recursively.
+ # If :mode => :preserve, preserve the file mode from the source.
+ # If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
+ #
+ # ==== Examples
+ #
+ # directory "doc"
+ # directory "doc", "docs", :recursive => false
+ #
+ # source://thor//lib/thor/actions/directory.rb#49
+ def directory(source, *args, &block); end
+
+ # Creates an empty directory.
+ #
+ # ==== Parameters
+ # destination:: the relative path to the destination root.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # empty_directory "doc"
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#13
+ def empty_directory(destination, config = T.unsafe(nil)); end
+
+ # Receives a file or directory and search for it in the source paths.
+ #
+ # @raise [Error]
+ #
+ # source://thor//lib/thor/actions.rb#133
+ def find_in_source_paths(file); end
+
+ # Gets the content at the given address and places it at the given relative
+ # destination. If a block is given instead of destination, the content of
+ # the url is yielded and used as location.
+ #
+ # +get+ relies on open-uri, so passing application user input would provide
+ # a command injection attack vector.
+ #
+ # ==== Parameters
+ # source:: the address of the given content.
+ # destination:: the relative path to the destination root.
+ # config:: give :verbose => false to not log the status, and
+ # :http_headers => to add headers to an http request.
+ #
+ # ==== Examples
+ #
+ # get "http://gist.github.com/103208", "doc/README"
+ #
+ # get "http://gist.github.com/103208", "doc/README", :http_headers => {"Content-Type" => "application/json"}
+ #
+ # get "http://gist.github.com/103208" do |content|
+ # content.split("\n").first
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#82
+ def get(source, *args, &block); end
+
+ # Run a regular expression replacement on a file.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # flag:: the regexp or string to be replaced
+ # replacement:: the replacement, can be also given as a block
+ # config:: give :verbose => false to not log the status, and
+ # :force => true, to force the replacement regardless of runner behavior.
+ #
+ # ==== Example
+ #
+ # gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+ #
+ # gsub_file 'README', /rake/, :green do |match|
+ # match << " no more. Use thor!"
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#263
+ def gsub_file(path, flag, *args, &block); end
+
+ # Goes to the root and execute the given block.
+ #
+ # source://thor//lib/thor/actions.rb#200
+ def in_root; end
+
+ # Injects text right after the class definition. Since it depends on
+ # insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # klass:: the class to be manipulated
+ # data:: the data to append to the class, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # inject_into_class "app/controllers/application_controller.rb", "ApplicationController", " filter_parameter :password\n"
+ #
+ # inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
+ # " filter_parameter :password\n"
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#217
+ def inject_into_class(path, klass, *args, &block); end
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#26
+ def inject_into_file(destination, *args, &block); end
+
+ # Injects text right after the module definition. Since it depends on
+ # insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # module_name:: the module to be manipulated
+ # data:: the data to append to the class, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", " def help; 'help'; end\n"
+ #
+ # inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
+ # " def help; 'help'; end\n"
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#240
+ def inject_into_module(path, module_name, *args, &block); end
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#26
+ def insert_into_file(destination, *args, &block); end
+
+ # Do something in the root or on a provided subfolder. If a relative path
+ # is given it's referenced from the current root. The full path is yielded
+ # to the block you provide. The path is set back to the previous path when
+ # the method exits.
+ #
+ # Returns the value yielded by the block.
+ #
+ # ==== Parameters
+ # dir:: the directory to move to.
+ # config:: give :verbose => true to log and use padding.
+ #
+ # source://thor//lib/thor/actions.rb#170
+ def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+ # Links the file from the relative source to the relative destination. If
+ # the destination is not given it's assumed to be equal to the source.
+ #
+ # ==== Parameters
+ # source:: the relative path to the source root.
+ # destination:: the relative path to the destination root.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # link_file "README", "doc/README"
+ #
+ # link_file "doc/README"
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#51
+ def link_file(source, *args); end
+
+ # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # data:: the data to prepend to the file, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+ #
+ # prepend_to_file 'config/environments/test.rb' do
+ # 'config.gem "rspec"'
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#171
+ def prepend_file(path, *args, &block); end
+
+ # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # data:: the data to prepend to the file, can be also given as a block.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+ #
+ # prepend_to_file 'config/environments/test.rb' do
+ # 'config.gem "rspec"'
+ # end
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#171
+ def prepend_to_file(path, *args, &block); end
+
+ # Returns the given path relative to the absolute root (ie, root where
+ # the script started).
+ #
+ # source://thor//lib/thor/actions.rb#114
+ def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
+
+ # Removes a file at the given location.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # remove_file 'README'
+ # remove_file 'app/controllers/application_controller.rb'
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#327
+ def remove_dir(path, config = T.unsafe(nil)); end
+
+ # Removes a file at the given location.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # remove_file 'README'
+ # remove_file 'app/controllers/application_controller.rb'
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#327
+ def remove_file(path, config = T.unsafe(nil)); end
+
+ # Executes a command returning the contents of the command.
+ #
+ # ==== Parameters
+ # command:: the command to be executed.
+ # config:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with
+ # to append an executable to command execution.
+ #
+ # ==== Example
+ #
+ # inside('vendor') do
+ # run('ln -s ~/edge rails')
+ # end
+ #
+ # source://thor//lib/thor/actions.rb#248
+ def run(command, config = T.unsafe(nil)); end
+
+ # Executes a ruby script (taking into account WIN32 platform quirks).
+ #
+ # ==== Parameters
+ # command:: the command to be executed.
+ # config:: give :verbose => false to not log the status.
+ #
+ # source://thor//lib/thor/actions.rb#285
+ def run_ruby_script(command, config = T.unsafe(nil)); end
+
+ # Holds source paths in instance so they can be manipulated.
+ #
+ # source://thor//lib/thor/actions.rb#127
+ def source_paths; end
+
+ # Gets an ERB template at the relative source, executes it and makes a copy
+ # at the relative destination. If the destination is not given it's assumed
+ # to be equal to the source removing .tt from the filename.
+ #
+ # ==== Parameters
+ # source:: the relative path to the source root.
+ # destination:: the relative path to the destination root.
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Examples
+ #
+ # template "README", "doc/README"
+ #
+ # template "doc/README"
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#118
+ def template(source, *args, &block); end
+
+ # Run a thor command. A hash of options can be given and it's converted to
+ # switches.
+ #
+ # ==== Parameters
+ # command:: the command to be invoked
+ # args:: arguments to the command
+ # config:: give :verbose => false to not log the status, :capture => true to hide to output.
+ # Other options are given as parameter to Thor.
+ #
+ #
+ # ==== Examples
+ #
+ # thor :install, "http://gist.github.com/103208"
+ # #=> thor install http://gist.github.com/103208
+ #
+ # thor :list, :all => true, :substring => 'rails'
+ # #=> thor list --all --substring=rails
+ #
+ # source://thor//lib/thor/actions.rb#308
+ def thor(command, *args); end
+
+ # Uncomment all lines matching a given regex. It will leave the space
+ # which existed before the comment hash in tact but will remove any spacing
+ # between the comment hash and the beginning of the line.
+ #
+ # ==== Parameters
+ # path:: path of the file to be changed
+ # flag:: the regexp or string used to decide which lines to uncomment
+ # config:: give :verbose => false to not log the status.
+ #
+ # ==== Example
+ #
+ # uncomment_lines 'config/initializers/session_store.rb', /active_record/
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#291
+ def uncomment_lines(path, flag, *args); end
+
+ protected
+
+ # source://thor//lib/thor/actions.rb#329
+ def _cleanup_options_and_set(options, key); end
+
+ # Allow current root to be shared between invocations.
+ #
+ # source://thor//lib/thor/actions.rb#325
+ def _shared_configuration; end
+
+ private
+
+ # source://thor//lib/thor/actions/file_manipulation.rb#348
+ def capture(*args); end
+
+ # source://thor//lib/thor/actions/file_manipulation.rb#344
+ def concat(string); end
+
+ # Returns the value of attribute output_buffer.
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#339
+ def output_buffer; end
+
+ # Sets the attribute output_buffer
+ #
+ # @param value the value to set the attribute output_buffer to.
+ #
+ # source://thor//lib/thor/actions/file_manipulation.rb#339
+ def output_buffer=(_arg0); end
+
+ # source://thor//lib/thor/actions/file_manipulation.rb#352
+ def with_output_buffer(buf = T.unsafe(nil)); end
+
+ class << self
+ # source://thor//lib/thor/actions.rb#12
+ def included(base); end
+ end
+end
+
+# Thor::Actions#capture depends on what kind of buffer is used in ERB.
+# Thus CapturableERB fixes ERB to use String buffer.
+#
+# source://thor//lib/thor/actions/file_manipulation.rb#364
+class Thor::Actions::CapturableERB < ::ERB
+ # source://thor//lib/thor/actions/file_manipulation.rb#365
+ def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
+end
+
+# source://thor//lib/thor/actions.rb#17
+module Thor::Actions::ClassMethods
+ # Add runtime options that help actions execution.
+ #
+ # source://thor//lib/thor/actions.rb#48
+ def add_runtime_options!; end
+
+ # Hold source paths for one Thor instance. source_paths_for_search is the
+ # method responsible to gather source_paths from this current class,
+ # inherited paths and the source root.
+ #
+ # source://thor//lib/thor/actions.rb#22
+ def source_paths; end
+
+ # Returns the source paths in the following order:
+ #
+ # 1) This class source paths
+ # 2) Source root
+ # 3) Parents source paths
+ #
+ # source://thor//lib/thor/actions.rb#38
+ def source_paths_for_search; end
+
+ # Stores and return the source root for this class
+ #
+ # source://thor//lib/thor/actions.rb#27
+ def source_root(path = T.unsafe(nil)); end
+end
+
+# CreateFile is a subset of Template, which instead of rendering a file with
+# ERB, it gets the content from the user.
+#
+# source://thor//lib/thor/actions/create_file.rb#32
+class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
+ # @return [CreateFile] a new instance of CreateFile
+ #
+ # source://thor//lib/thor/actions/create_file.rb#35
+ def initialize(base, destination, data, config = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/actions/create_file.rb#33
+ def data; end
+
+ # Checks if the content of the file at the destination is identical to the rendered result.
+ #
+ # ==== Returns
+ # Boolean:: true if it is identical, false otherwise.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/create_file.rb#45
+ def identical?; end
+
+ # source://thor//lib/thor/actions/create_file.rb#60
+ def invoke!; end
+
+ # Holds the content to be added to the file.
+ #
+ # source://thor//lib/thor/actions/create_file.rb#52
+ def render; end
+
+ protected
+
+ # Shows the file collision menu to the user and gets the result.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/create_file.rb#100
+ def force_on_collision?; end
+
+ # If force is true, run the action, otherwise check if it's not being
+ # skipped. If both are false, show the file_collision menu, if the menu
+ # returns true, force it, otherwise skip.
+ #
+ # source://thor//lib/thor/actions/create_file.rb#86
+ def force_or_skip_or_conflict(force, skip, &block); end
+
+ # Now on conflict we check if the file is identical or not.
+ #
+ # source://thor//lib/thor/actions/create_file.rb#73
+ def on_conflict_behavior(&block); end
+end
+
+# CreateLink is a subset of CreateFile, which instead of taking a block of
+# data, just takes a source string from the user.
+#
+# source://thor//lib/thor/actions/create_link.rb#27
+class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
+ # source://thor//lib/thor/actions/create_link.rb#28
+ def data; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/create_link.rb#56
+ def exists?; end
+
+ # Checks if the content of the file at the destination is identical to the rendered result.
+ #
+ # ==== Returns
+ # Boolean:: true if it is identical, false otherwise.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/create_link.rb#35
+ def identical?; end
+
+ # source://thor//lib/thor/actions/create_link.rb#40
+ def invoke!; end
+end
+
+# source://thor//lib/thor/actions/directory.rb#55
+class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
+ # @return [Directory] a new instance of Directory
+ #
+ # source://thor//lib/thor/actions/directory.rb#58
+ def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+ # source://thor//lib/thor/actions/directory.rb#64
+ def invoke!; end
+
+ # source://thor//lib/thor/actions/directory.rb#69
+ def revoke!; end
+
+ # Returns the value of attribute source.
+ #
+ # source://thor//lib/thor/actions/directory.rb#56
+ def source; end
+
+ protected
+
+ # source://thor//lib/thor/actions/directory.rb#75
+ def execute!; end
+
+ # source://thor//lib/thor/actions/directory.rb#99
+ def file_level_lookup(previous_lookup); end
+
+ # source://thor//lib/thor/actions/directory.rb#103
+ def files(lookup); end
+end
+
+# source://thor//lib/thor/actions/empty_directory.rb#23
+class Thor::Actions::EmptyDirectory
+ # Initializes given the source and destination.
+ #
+ # ==== Parameters
+ # base:: A Thor::Base instance
+ # source:: Relative path to the source of this file
+ # destination:: Relative path to the destination of this file
+ # config:: give :verbose => false to not log the status.
+ #
+ # @return [EmptyDirectory] a new instance of EmptyDirectory
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#34
+ def initialize(base, destination, config = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#24
+ def base; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#24
+ def config; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#24
+ def destination; end
+
+ # Checks if the destination file already exists.
+ #
+ # ==== Returns
+ # Boolean:: true if the file exists, false otherwise.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#45
+ def exists?; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#24
+ def given_destination; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#49
+ def invoke!; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#24
+ def relative_destination; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#56
+ def revoke!; end
+
+ protected
+
+ # Filenames in the encoded form are converted. If you have a file:
+ #
+ # %file_name%.rb
+ #
+ # It calls #file_name from the base and replaces %-string with the
+ # return value (should be String) of #file_name:
+ #
+ # user.rb
+ #
+ # The method referenced can be either public or private.
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#103
+ def convert_encoded_instructions(filename); end
+
+ # Sets the absolute destination value from a relative destination value.
+ # It also stores the given and relative destination. Let's suppose our
+ # script is being executed on "dest", it sets the destination root to
+ # "dest". The destination, given_destination and relative_destination
+ # are related in the following way:
+ #
+ # inside "bar" do
+ # empty_directory "baz"
+ # end
+ #
+ # destination #=> dest/bar/baz
+ # relative_destination #=> bar/baz
+ # given_destination #=> baz
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#85
+ def destination=(destination); end
+
+ # Receives a hash of options and just execute the block if some
+ # conditions are met.
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#113
+ def invoke_with_conflict_check(&block); end
+
+ # What to do when the destination file already exists.
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#132
+ def on_conflict_behavior; end
+
+ # source://thor//lib/thor/actions/empty_directory.rb#126
+ def on_file_clash_behavior; end
+
+ # Shortcut for pretend.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#67
+ def pretend?; end
+
+ # Shortcut to say_status shell method.
+ #
+ # source://thor//lib/thor/actions/empty_directory.rb#138
+ def say_status(status, color); end
+end
+
+# source://thor//lib/thor/actions/inject_into_file.rb#36
+class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
+ # @return [InjectIntoFile] a new instance of InjectIntoFile
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#39
+ def initialize(base, destination, data, config); end
+
+ # Returns the value of attribute behavior.
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#37
+ def behavior; end
+
+ # Returns the value of attribute flag.
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#37
+ def flag; end
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#52
+ def invoke!; end
+
+ # Returns the value of attribute replacement.
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#37
+ def replacement; end
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#74
+ def revoke!; end
+
+ protected
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#110
+ def content; end
+
+ # Adds the content to the file.
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#120
+ def replace!(regexp, string, force); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/actions/inject_into_file.rb#114
+ def replacement_present?; end
+
+ # source://thor//lib/thor/actions/inject_into_file.rb#90
+ def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
+end
+
+# Injects the given content into a file. Different from gsub_file, this
+# method is reversible.
+#
+# ==== Parameters
+# destination:: Relative path to the destination root
+# data:: Data to add to the file. Can be given as a block.
+# config:: give :verbose => false to not log the status and the flag
+# for injection (:after or :before) or :force => true for
+# insert two or more times the same content.
+#
+# ==== Examples
+#
+# insert_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
+#
+# insert_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+# gems = ask "Which gems would you like to add?"
+# gems.split(" ").map{ |gem| " config.gem :#{gem}" }.join("\n")
+# end
+#
+# source://thor//lib/thor/actions/inject_into_file.rb#24
+Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
+
+# source://thor//lib/thor/error.rb#57
+class Thor::AmbiguousCommandError < ::Thor::Error; end
+
+# source://thor//lib/thor/error.rb#59
+Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
+
+# source://thor//lib/thor/parser/argument.rb#2
+class Thor::Argument
+ # @raise [ArgumentError]
+ # @return [Argument] a new instance of Argument
+ #
+ # source://thor//lib/thor/parser/argument.rb#8
+ def initialize(name, options = T.unsafe(nil)); end
+
+ # Returns the value of attribute banner.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def banner; end
+
+ # Returns the value of attribute default.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def default; end
+
+ # Returns the value of attribute description.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def description; end
+
+ # Returns the value of attribute enum.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def enum; end
+
+ # source://thor//lib/thor/parser/argument.rb#55
+ def enum_to_s; end
+
+ # Returns the value of attribute name.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def human_name; end
+
+ # Returns the value of attribute name.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def name; end
+
+ # source://thor//lib/thor/parser/argument.rb#27
+ def print_default; end
+
+ # Returns the value of attribute required.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def required; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/argument.rb#42
+ def required?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/argument.rb#46
+ def show_default?; end
+
+ # Returns the value of attribute type.
+ #
+ # source://thor//lib/thor/parser/argument.rb#5
+ def type; end
+
+ # source://thor//lib/thor/parser/argument.rb#38
+ def usage; end
+
+ protected
+
+ # source://thor//lib/thor/parser/argument.rb#74
+ def default_banner; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/argument.rb#70
+ def valid_type?(type); end
+
+ # @raise [ArgumentError]
+ #
+ # source://thor//lib/thor/parser/argument.rb#65
+ def validate!; end
+end
+
+# source://thor//lib/thor/parser/argument.rb#3
+Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/parser/arguments.rb#2
+class Thor::Arguments
+ # Takes an array of Thor::Argument objects.
+ #
+ # @return [Arguments] a new instance of Arguments
+ #
+ # source://thor//lib/thor/parser/arguments.rb#26
+ def initialize(arguments = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/parser/arguments.rb#40
+ def parse(args); end
+
+ # source://thor//lib/thor/parser/arguments.rb#53
+ def remaining; end
+
+ private
+
+ # Raises an error if @non_assigned_required array is not empty.
+ #
+ # @raise [RequiredArgumentMissingError]
+ #
+ # source://thor//lib/thor/parser/arguments.rb#186
+ def check_requirement!; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/arguments.rb#84
+ def current_is_value?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/arguments.rb#64
+ def last?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/arguments.rb#59
+ def no_or_skip?(arg); end
+
+ # Runs through the argument array getting all strings until no string is
+ # found or a switch is found.
+ #
+ # ["a", "b", "c"]
+ #
+ # And returns it as an array:
+ #
+ # ["a", "b", "c"]
+ #
+ # source://thor//lib/thor/parser/arguments.rb#118
+ def parse_array(name); end
+
+ # Runs through the argument array getting strings that contains ":" and
+ # mark it as a hash:
+ #
+ # [ "name:string", "age:integer" ]
+ #
+ # Becomes:
+ #
+ # { "name" => "string", "age" => "integer" }
+ #
+ # source://thor//lib/thor/parser/arguments.rb#97
+ def parse_hash(name); end
+
+ # Check if the peek is numeric format and return a Float or Integer.
+ # Check if the peek is included in enum if enum is provided.
+ # Otherwise raises an error.
+ #
+ # source://thor//lib/thor/parser/arguments.rb#139
+ def parse_numeric(name); end
+
+ # Parse string:
+ # for --string-arg, just return the current value in the pile
+ # for --no-string-arg, nil
+ # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
+ #
+ # source://thor//lib/thor/parser/arguments.rb#158
+ def parse_string(name); end
+
+ # source://thor//lib/thor/parser/arguments.rb#68
+ def peek; end
+
+ # source://thor//lib/thor/parser/arguments.rb#72
+ def shift; end
+
+ # source://thor//lib/thor/parser/arguments.rb#76
+ def unshift(arg); end
+
+ # Raises an error if the switch is an enum and the values aren't included on it.
+ #
+ # source://thor//lib/thor/parser/arguments.rb#172
+ def validate_enum_value!(name, value, message); end
+
+ class << self
+ # source://thor//lib/thor/parser/arguments.rb#19
+ def parse(*args); end
+
+ # Receives an array of args and returns two arrays, one with arguments
+ # and one with switches.
+ #
+ # source://thor//lib/thor/parser/arguments.rb#8
+ def split(args); end
+ end
+end
+
+# source://thor//lib/thor/parser/arguments.rb#3
+Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/error.rb#104
+class Thor::AtLeastOneRequiredArgumentError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/shell.rb#4
+module Thor::Base
+ include ::Thor::Invocation
+ include ::Thor::Shell
+
+ mixes_in_class_methods ::Thor::Base::ClassMethods
+ mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+ # It receives arguments in an Array and two hashes, one for options and
+ # other for configuration.
+ #
+ # Notice that it does not check if all required arguments were supplied.
+ # It should be done by the parser.
+ #
+ # ==== Parameters
+ # args:: An array of objects. The objects are applied to their
+ # respective accessors declared with argument.
+ #
+ # options:: An options hash that will be available as self.options.
+ # The hash given is converted to a hash with indifferent
+ # access, magic predicates (options.skip?) and then frozen.
+ #
+ # config:: Configuration for this Thor class.
+ #
+ # source://thor//lib/thor/base.rb#53
+ def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+ # Returns the value of attribute args.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def args; end
+
+ # Sets the attribute args
+ #
+ # @param value the value to set the attribute args to.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def args=(_arg0); end
+
+ # Returns the value of attribute options.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def options; end
+
+ # Sets the attribute options
+ #
+ # @param value the value to set the attribute options to.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def options=(_arg0); end
+
+ # Returns the value of attribute parent_options.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def parent_options; end
+
+ # Sets the attribute parent_options
+ #
+ # @param value the value to set the attribute parent_options to.
+ #
+ # source://thor//lib/thor/base.rb#35
+ def parent_options=(_arg0); end
+
+ class << self
+ # source://thor//lib/thor/base.rb#116
+ def included(base); end
+
+ # Whenever a class inherits from Thor or Thor::Group, we should track the
+ # class and the file on Thor::Base. This is the method responsible for it.
+ #
+ # source://thor//lib/thor/base.rb#144
+ def register_klass_file(klass); end
+
+ # Returns the shell used in all Thor classes. If you are in a Unix platform
+ # it will use a colored log, otherwise it will use a basic one without color.
+ #
+ # source://thor//lib/thor/shell.rb#11
+ def shell; end
+
+ # Sets the attribute shell
+ #
+ # @param value the value to set the attribute shell to.
+ #
+ # source://thor//lib/thor/shell.rb#6
+ def shell=(_arg0); end
+
+ # Returns the files where the subclasses are kept.
+ #
+ # ==== Returns
+ # Hash[path => Class]
+ #
+ # source://thor//lib/thor/base.rb#137
+ def subclass_files; end
+
+ # Returns the classes that inherits from Thor or Thor::Group.
+ #
+ # ==== Returns
+ # Array[Class]
+ #
+ # source://thor//lib/thor/base.rb#128
+ def subclasses; end
+ end
+end
+
+# source://thor//lib/thor/base.rb#153
+module Thor::Base::ClassMethods
+ # Returns the commands for this Thor class and all subclasses.
+ #
+ # ==== Returns
+ # Hash:: An ordered hash with commands names as keys and Thor::Command
+ # objects as values.
+ #
+ # source://thor//lib/thor/base.rb#482
+ def all_commands; end
+
+ # Returns the commands for this Thor class and all subclasses.
+ #
+ # ==== Returns
+ # Hash:: An ordered hash with commands names as keys and Thor::Command
+ # objects as values.
+ #
+ # source://thor//lib/thor/base.rb#482
+ def all_tasks; end
+
+ # If you want to use defaults that don't match the type of an option,
+ # either specify `check_default_type: false` or call `allow_incompatible_default_type!`
+ #
+ # source://thor//lib/thor/base.rb#189
+ def allow_incompatible_default_type!; end
+
+ # Adds an argument to the class and creates an attr_accessor for it.
+ #
+ # Arguments are different from options in several aspects. The first one
+ # is how they are parsed from the command line, arguments are retrieved
+ # from position:
+ #
+ # thor command NAME
+ #
+ # Instead of:
+ #
+ # thor command --name=NAME
+ #
+ # Besides, arguments are used inside your code as an accessor (self.argument),
+ # while options are all kept in a hash (self.options).
+ #
+ # Finally, arguments cannot have type :default or :boolean but can be
+ # optional (supplying :optional => :true or :required => false), although
+ # you cannot have a required argument after a non-required argument. If you
+ # try it, an error is raised.
+ #
+ # ==== Parameters
+ # name:: The name of the argument.
+ # options:: Described below.
+ #
+ # ==== Options
+ # :desc - Description for the argument.
+ # :required - If the argument is required or not.
+ # :optional - If the argument is optional or not.
+ # :type - The type of the argument, can be :string, :hash, :array, :numeric.
+ # :default - Default value for this argument. It cannot be required and have default values.
+ # :banner - String to show on usage notes.
+ #
+ # ==== Errors
+ # ArgumentError:: Raised if you supply a required argument after a non required one.
+ #
+ # source://thor//lib/thor/base.rb#261
+ def argument(name, options = T.unsafe(nil)); end
+
+ # Returns this class arguments, looking up in the ancestors chain.
+ #
+ # ==== Returns
+ # Array[Thor::Argument]
+ #
+ # source://thor//lib/thor/base.rb#293
+ def arguments; end
+
+ # source://thor//lib/thor/base.rb#162
+ def attr_accessor(*_arg0); end
+
+ # source://thor//lib/thor/base.rb#154
+ def attr_reader(*_arg0); end
+
+ # source://thor//lib/thor/base.rb#158
+ def attr_writer(*_arg0); end
+
+ # source://thor//lib/thor/base.rb#193
+ def check_default_type; end
+
+ # If you want to raise an error when the default value of an option does not match
+ # the type call check_default_type!
+ # This will be the default; for compatibility a deprecation warning is issued if necessary.
+ #
+ # source://thor//lib/thor/base.rb#183
+ def check_default_type!; end
+
+ # source://thor//lib/thor/base.rb#172
+ def check_unknown_options; end
+
+ # If you want to raise an error for unknown options, call check_unknown_options!
+ # This is disabled by default to allow dynamic invocations.
+ #
+ # source://thor//lib/thor/base.rb#168
+ def check_unknown_options!; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#176
+ def check_unknown_options?(config); end
+
+ # Adds and declares option group for required at least one of options in the
+ # block and arguments. You can declare options as the outside of the block.
+ #
+ # ==== Examples
+ #
+ # class_at_least_one do
+ # class_option :one
+ # class_option :two
+ # end
+ #
+ # Or
+ #
+ # class_option :one
+ # class_option :two
+ # class_at_least_one :one, :two
+ #
+ # If you do not give "--one" and "--two" AtLeastOneRequiredArgumentError
+ # will be raised.
+ #
+ # You can use class_at_least_one and class_exclusive at the same time.
+ #
+ # class_exclusive do
+ # class_at_least_one do
+ # class_option :one
+ # class_option :two
+ # end
+ # end
+ #
+ # Then it is required either only one of "--one" or "--two".
+ #
+ # source://thor//lib/thor/base.rb#392
+ def class_at_least_one(*args, &block); end
+
+ # Returns this class at least one of required options array set, looking up in the ancestors chain.
+ #
+ # ==== Returns
+ # Array[Array[Thor::Option.name]]
+ #
+ # source://thor//lib/thor/base.rb#411
+ def class_at_least_one_option_names; end
+
+ # Adds and declares option group for exclusive options in the
+ # block and arguments. You can declare options as the outside of the block.
+ #
+ # ==== Parameters
+ # Array[Thor::Option.name]
+ #
+ # ==== Examples
+ #
+ # class_exclusive do
+ # class_option :one
+ # class_option :two
+ # end
+ #
+ # Or
+ #
+ # class_option :one
+ # class_option :two
+ # class_exclusive :one, :two
+ #
+ # If you give "--one" and "--two" at the same time ExclusiveArgumentsError
+ # will be raised.
+ #
+ # source://thor//lib/thor/base.rb#357
+ def class_exclusive(*args, &block); end
+
+ # Returns this class exclusive options array set, looking up in the ancestors chain.
+ #
+ # ==== Returns
+ # Array[Array[Thor::Option.name]]
+ #
+ # source://thor//lib/thor/base.rb#402
+ def class_exclusive_option_names; end
+
+ # Adds an option to the set of class options
+ #
+ # ==== Parameters
+ # name:: The name of the argument.
+ # options:: Described below.
+ #
+ # ==== Options
+ # :desc:: -- Description for the argument.
+ # :required:: -- If the argument is required or not.
+ # :default:: -- Default value for this argument.
+ # :group:: -- The group for this options. Use by class options to output options in different levels.
+ # :aliases:: -- Aliases for this option. Note: Thor follows a convention of one-dash-one-letter options. Thus aliases like "-something" wouldn't be parsed; use either "\--something" or "-s" instead.
+ # :type:: -- The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+ # :banner:: -- String to show on usage notes.
+ # :hide:: -- If you want to hide this option from the help.
+ #
+ # source://thor//lib/thor/base.rb#328
+ def class_option(name, options = T.unsafe(nil)); end
+
+ # Adds a bunch of options to the set of class options.
+ #
+ # class_options :foo => false, :bar => :required, :baz => :string
+ #
+ # If you prefer more detailed declaration, check class_option.
+ #
+ # ==== Parameters
+ # Hash[Symbol => Object]
+ #
+ # source://thor//lib/thor/base.rb#306
+ def class_options(options = T.unsafe(nil)); end
+
+ # Returns the commands for this Thor class.
+ #
+ # ==== Returns
+ # Hash:: An ordered hash with commands names as keys and Thor::Command
+ # objects as values.
+ #
+ # source://thor//lib/thor/base.rb#471
+ def commands; end
+
+ # If true, option set will not suspend the execution of the command when
+ # a required option is not provided.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#207
+ def disable_required_check?(command_name); end
+
+ # A flag that makes the process exit with status 1 if any error happens.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#628
+ def exit_on_failure?; end
+
+ # Defines the group. This is used when thor list is invoked so you can specify
+ # that only commands from a pre-defined group will be shown. Defaults to standard.
+ #
+ # ==== Parameters
+ # name
+ #
+ # source://thor//lib/thor/base.rb#457
+ def group(name = T.unsafe(nil)); end
+
+ # @raise [InvocationError]
+ #
+ # source://thor//lib/thor/base.rb#618
+ def handle_argument_error(command, error, args, arity); end
+
+ # @raise [UndefinedCommandError]
+ #
+ # source://thor//lib/thor/base.rb#613
+ def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
+
+ # @raise [UndefinedCommandError]
+ #
+ # source://thor//lib/thor/base.rb#613
+ def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
+
+ # Sets the namespace for the Thor or Thor::Group class. By default the
+ # namespace is retrieved from the class name. If your Thor class is named
+ # Scripts::MyScript, the help method, for example, will be called as:
+ #
+ # thor scripts:my_script -h
+ #
+ # If you change the namespace:
+ #
+ # namespace :my_scripts
+ #
+ # You change how your commands are invoked:
+ #
+ # thor my_scripts -h
+ #
+ # Finally, if you change your namespace to default:
+ #
+ # namespace :default
+ #
+ # Your commands can be invoked with a shortcut. Instead of:
+ #
+ # thor :my_command
+ #
+ # source://thor//lib/thor/base.rb#566
+ def namespace(name = T.unsafe(nil)); end
+
+ # All methods defined inside the given block are not added as commands.
+ #
+ # So you can do:
+ #
+ # class MyScript < Thor
+ # no_commands do
+ # def this_is_not_a_command
+ # end
+ # end
+ # end
+ #
+ # You can also add the method and remove it from the command list:
+ #
+ # class MyScript < Thor
+ # def this_is_not_a_command
+ # end
+ # remove_command :this_is_not_a_command
+ # end
+ #
+ # source://thor//lib/thor/base.rb#530
+ def no_commands(&block); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#540
+ def no_commands?; end
+
+ # source://thor//lib/thor/base.rb#536
+ def no_commands_context; end
+
+ # All methods defined inside the given block are not added as commands.
+ #
+ # So you can do:
+ #
+ # class MyScript < Thor
+ # no_commands do
+ # def this_is_not_a_command
+ # end
+ # end
+ # end
+ #
+ # You can also add the method and remove it from the command list:
+ #
+ # class MyScript < Thor
+ # def this_is_not_a_command
+ # end
+ # remove_command :this_is_not_a_command
+ # end
+ #
+ # source://thor//lib/thor/base.rb#530
+ def no_tasks(&block); end
+
+ # Allows to use private methods from parent in child classes as commands.
+ #
+ # ==== Parameters
+ # names:: Method names to be used as commands
+ #
+ # ==== Examples
+ #
+ # public_command :foo
+ # public_command :foo, :bar, :baz
+ #
+ # source://thor//lib/thor/base.rb#606
+ def public_command(*names); end
+
+ # Allows to use private methods from parent in child classes as commands.
+ #
+ # ==== Parameters
+ # names:: Method names to be used as commands
+ #
+ # ==== Examples
+ #
+ # public_command :foo
+ # public_command :foo, :bar, :baz
+ #
+ # source://thor//lib/thor/base.rb#606
+ def public_task(*names); end
+
+ # Removes a previous defined argument. If :undefine is given, undefine
+ # accessors as well.
+ #
+ # ==== Parameters
+ # names:: Arguments to be removed
+ #
+ # ==== Examples
+ #
+ # remove_argument :foo
+ # remove_argument :foo, :bar, :baz, :undefine => true
+ #
+ # source://thor//lib/thor/base.rb#426
+ def remove_argument(*names); end
+
+ # Removes a previous defined class option.
+ #
+ # ==== Parameters
+ # names:: Class options to be removed
+ #
+ # ==== Examples
+ #
+ # remove_class_option :foo
+ # remove_class_option :foo, :bar, :baz
+ #
+ # source://thor//lib/thor/base.rb#445
+ def remove_class_option(*names); end
+
+ # Removes a given command from this Thor class. This is usually done if you
+ # are inheriting from another class and don't want it to be available
+ # anymore.
+ #
+ # By default it only remove the mapping to the command. But you can supply
+ # :undefine => true to undefine the method from the class as well.
+ #
+ # ==== Parameters
+ # name:: The name of the command to be removed
+ # options:: You can give :undefine => true if you want commands the method
+ # to be undefined from the class as well.
+ #
+ # source://thor//lib/thor/base.rb#500
+ def remove_command(*names); end
+
+ # Removes a given command from this Thor class. This is usually done if you
+ # are inheriting from another class and don't want it to be available
+ # anymore.
+ #
+ # By default it only remove the mapping to the command. But you can supply
+ # :undefine => true to undefine the method from the class as well.
+ #
+ # ==== Parameters
+ # name:: The name of the command to be removed
+ # options:: You can give :undefine => true if you want commands the method
+ # to be undefined from the class as well.
+ #
+ # source://thor//lib/thor/base.rb#500
+ def remove_task(*names); end
+
+ # Parses the command and options from the given args, instantiate the class
+ # and invoke the command. This method is used when the arguments must be parsed
+ # from an array. If you are inside Ruby and want to use a Thor class, you
+ # can simply initialize it:
+ #
+ # script = MyScript.new(args, options, config)
+ # script.invoke(:command, first_arg, second_arg, third_arg)
+ #
+ # source://thor//lib/thor/base.rb#582
+ def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
+
+ # If true, option parsing is suspended as soon as an unknown option or a
+ # regular argument is encountered. All remaining arguments are passed to
+ # the command as regular arguments.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#201
+ def stop_on_unknown_option?(command_name); end
+
+ # source://thor//lib/thor/base.rb#218
+ def strict_args_position; end
+
+ # If you want only strict string args (useful when cascading thor classes),
+ # call strict_args_position! This is disabled by default to allow dynamic
+ # invocations.
+ #
+ # source://thor//lib/thor/base.rb#214
+ def strict_args_position!; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#222
+ def strict_args_position?(config); end
+
+ # Returns the commands for this Thor class.
+ #
+ # ==== Returns
+ # Hash:: An ordered hash with commands names as keys and Thor::Command
+ # objects as values.
+ #
+ # source://thor//lib/thor/base.rb#471
+ def tasks; end
+
+ protected
+
+ # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+ # finishes.
+ #
+ # source://thor//lib/thor/base.rb#777
+ def baseclass; end
+
+ # The basename of the program invoking the thor class.
+ #
+ # source://thor//lib/thor/base.rb#771
+ def basename; end
+
+ # Build an option and adds it to the given scope.
+ #
+ # ==== Parameters
+ # name:: The name of the argument.
+ # options:: Described in both class_option and method_option.
+ # scope:: Options hash that is being built up
+ #
+ # source://thor//lib/thor/base.rb#688
+ def build_option(name, options, scope); end
+
+ # Receives a hash of options, parse them and add to the scope. This is a
+ # fast way to set a bunch of options:
+ #
+ # build_options :foo => true, :bar => :required, :baz => :string
+ #
+ # ==== Parameters
+ # Hash[Symbol => Object]
+ #
+ # source://thor//lib/thor/base.rb#699
+ def build_options(options, scope); end
+
+ # Get target(method_options or class_options) options
+ # of before and after by block evaluation.
+ #
+ # source://thor//lib/thor/base.rb#808
+ def built_option_names(target, opt = T.unsafe(nil), &block); end
+
+ # Prints the class options per group. If an option does not belong to
+ # any group, it's printed as Class option.
+ #
+ # source://thor//lib/thor/base.rb#638
+ def class_options_help(shell, groups = T.unsafe(nil)); end
+
+ # Get command scope member by name.
+ #
+ # source://thor//lib/thor/base.rb#816
+ def command_scope_member(name, options = T.unsafe(nil)); end
+
+ # SIGNATURE: Creates a new command if valid_command? is true. This method is
+ # called when a new method is added to the class.
+ #
+ # source://thor//lib/thor/base.rb#782
+ def create_command(meth); end
+
+ # SIGNATURE: Creates a new command if valid_command? is true. This method is
+ # called when a new method is added to the class.
+ #
+ # source://thor//lib/thor/base.rb#782
+ def create_task(meth); end
+
+ # SIGNATURE: The hook invoked by start.
+ #
+ # @raise [NotImplementedError]
+ #
+ # source://thor//lib/thor/base.rb#792
+ def dispatch(command, given_args, given_opts, config); end
+
+ # Finds a command with the given name. If the command belongs to the current
+ # class, just return it, otherwise dup it and add the fresh copy to the
+ # current command hash.
+ #
+ # source://thor//lib/thor/base.rb#708
+ def find_and_refresh_command(name); end
+
+ # Finds a command with the given name. If the command belongs to the current
+ # class, just return it, otherwise dup it and add the fresh copy to the
+ # current command hash.
+ #
+ # source://thor//lib/thor/base.rb#708
+ def find_and_refresh_task(name); end
+
+ # Retrieves a value from superclass. If it reaches the baseclass,
+ # returns default.
+ #
+ # source://thor//lib/thor/base.rb#749
+ def from_superclass(method, default = T.unsafe(nil)); end
+
+ # Every time someone inherits from a Thor class, register the klass
+ # and file into baseclass.
+ #
+ # source://thor//lib/thor/base.rb#721
+ def inherited(klass); end
+
+ # SIGNATURE: Defines behavior when the initialize method is added to the
+ # class.
+ #
+ # source://thor//lib/thor/base.rb#788
+ def initialize_added; end
+
+ # Raises an error if the word given is a Thor reserved word.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/base.rb#677
+ def is_thor_reserved_word?(word, type); end
+
+ # Fire this callback whenever a method is added. Added methods are
+ # tracked as commands by invoking the create_command method.
+ #
+ # source://thor//lib/thor/base.rb#729
+ def method_added(meth); end
+
+ # Receives a set of options and print them.
+ #
+ # source://thor//lib/thor/base.rb#656
+ def print_options(shell, options, group_name = T.unsafe(nil)); end
+
+ # Register a relation of options for target(method_option/class_option)
+ # by args and block.
+ #
+ # source://thor//lib/thor/base.rb#798
+ def register_options_relation_for(target, relation, *args, &block); end
+end
+
+# source://thor//lib/thor/command.rb#2
+class Thor::Command < ::Struct
+ # @return [Command] a new instance of Command
+ #
+ # source://thor//lib/thor/command.rb#5
+ def initialize(name, description, long_description, wrap_long_description, usage, options = T.unsafe(nil), options_relation = T.unsafe(nil)); end
+
+ # Returns the formatted usage by injecting given required arguments
+ # and required options into the given usage.
+ #
+ # source://thor//lib/thor/command.rb#42
+ def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#15
+ def hidden?; end
+
+ # source://thor//lib/thor/command.rb#70
+ def method_at_least_one_option_names; end
+
+ # source://thor//lib/thor/command.rb#66
+ def method_exclusive_option_names; end
+
+ # By default, a command invokes a method in the thor class. You can change this
+ # implementation to create custom commands.
+ #
+ # source://thor//lib/thor/command.rb#21
+ def run(instance, args = T.unsafe(nil)); end
+
+ protected
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#114
+ def handle_argument_error?(instance, error, caller); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#121
+ def handle_no_method_error?(instance, error, caller); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#104
+ def local_method?(instance, name); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#87
+ def not_debugging?(instance); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#100
+ def private_method?(instance); end
+
+ # Given a target, checks if this class name is a public method.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#96
+ def public_method?(instance); end
+
+ # Add usage with required arguments
+ #
+ # source://thor//lib/thor/command.rb#77
+ def required_arguments_for(klass, usage); end
+
+ # source://thor//lib/thor/command.rb#91
+ def required_options; end
+
+ # source://thor//lib/thor/command.rb#109
+ def sans_backtrace(backtrace, caller); end
+
+ private
+
+ # source://thor//lib/thor/command.rb#9
+ def initialize_copy(other); end
+end
+
+# source://thor//lib/thor/command.rb#3
+Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#2
+module Thor::CoreExt; end
+
+# A hash with indifferent access and magic predicates.
+#
+# hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+#
+# hash[:foo] #=> 'bar'
+# hash['foo'] #=> 'bar'
+# hash.foo? #=> true
+#
+# source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#11
+class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
+ # @return [HashWithIndifferentAccess] a new instance of HashWithIndifferentAccess
+ #
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#12
+ def initialize(hash = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#19
+ def [](key); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#23
+ def []=(key, value); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#27
+ def delete(key); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#31
+ def except(*keys); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#37
+ def fetch(key, *args); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#45
+ def key?(key); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#53
+ def merge(other); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#57
+ def merge!(other); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#72
+ def replace(other_hash); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#64
+ def reverse_merge(other); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#68
+ def reverse_merge!(other_hash); end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#41
+ def slice(*keys); end
+
+ # Convert to a Hash with String keys.
+ #
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#77
+ def to_hash; end
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#49
+ def values_at(*indices); end
+
+ protected
+
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#83
+ def convert_key(key); end
+
+ # Magic predicates. For instance:
+ #
+ # options.force? # => !!options['force']
+ # options.shebang # => "/usr/lib/local/ruby"
+ # options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+ #
+ # source://thor//lib/thor/core_ext/hash_with_indifferent_access.rb#93
+ def method_missing(method, *args); end
+end
+
+# source://thor//lib/thor/error.rb#3
+module Thor::Correctable
+ # source://thor//lib/thor/error.rb#8
+ def corrections; end
+
+ # source://thor//lib/thor/error.rb#4
+ def to_s; end
+end
+
+# A dynamic command that handles method missing scenarios.
+#
+# source://thor//lib/thor/command.rb#137
+class Thor::DynamicCommand < ::Thor::Command
+ # @return [DynamicCommand] a new instance of DynamicCommand
+ #
+ # source://thor//lib/thor/command.rb#138
+ def initialize(name, options = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/command.rb#142
+ def run(instance, args = T.unsafe(nil)); end
+end
+
+# source://thor//lib/thor/command.rb#150
+Thor::DynamicTask = Thor::DynamicCommand
+
+# Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+# errors have their backtrace suppressed and are nicely shown to the user.
+#
+# Errors that are caused by the developer, like declaring a method which
+# overwrites a thor keyword, SHOULD NOT raise a Thor::Error. This way, we
+# ensure that developer errors are shown with full backtrace.
+#
+# source://thor//lib/thor/error.rb#20
+class Thor::Error < ::StandardError; end
+
+# source://thor//lib/thor/error.rb#101
+class Thor::ExclusiveArgumentError < ::Thor::InvocationError; end
+
+# Thor has a special class called Thor::Group. The main difference to Thor class
+# is that it invokes all commands at once. It also include some methods that allows
+# invocations to be done at the class method, which are not available to Thor
+# commands.
+#
+# source://thor//lib/thor/group.rb#7
+class Thor::Group
+ include ::Thor::Base
+ include ::Thor::Invocation
+ include ::Thor::Shell
+ extend ::Thor::Base::ClassMethods
+ extend ::Thor::Invocation::ClassMethods
+
+ protected
+
+ # Shortcut to invoke with padding and block handling. Use internally by
+ # invoke and invoke_from_option class methods.
+ #
+ # source://thor//lib/thor/group.rb#265
+ def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
+
+ class << self
+ # Overwrite class options help to allow invoked generators options to be
+ # shown recursively when invoking a generator.
+ #
+ # source://thor//lib/thor/group.rb#161
+ def class_options_help(shell, groups = T.unsafe(nil)); end
+
+ # The description for this Thor::Group. If none is provided, but a source root
+ # exists, tries to find the USAGE one folder above it, otherwise searches
+ # in the superclass.
+ #
+ # ==== Parameters
+ # description:: The description for this Thor::Group.
+ #
+ # source://thor//lib/thor/group.rb#16
+ def desc(description = T.unsafe(nil)); end
+
+ # Get invocations array and merge options from invocations. Those
+ # options are added to group_options hash. Options that already exists
+ # in base_options are not added twice.
+ #
+ # source://thor//lib/thor/group.rb#172
+ def get_options_from_invocations(group_options, base_options); end
+
+ # @raise [error]
+ #
+ # source://thor//lib/thor/group.rb#207
+ def handle_argument_error(command, error, _args, arity); end
+
+ # Prints help information.
+ #
+ # ==== Options
+ # short:: When true, shows only usage.
+ #
+ # source://thor//lib/thor/group.rb#29
+ def help(shell); end
+
+ # Stores invocation blocks used on invoke_from_option.
+ #
+ # source://thor//lib/thor/group.rb#45
+ def invocation_blocks; end
+
+ # Stores invocations for this class merging with superclass values.
+ #
+ # source://thor//lib/thor/group.rb#39
+ def invocations; end
+
+ # Invoke the given namespace or class given. It adds an instance
+ # method that will invoke the klass and command. You can give a block to
+ # configure how it will be invoked.
+ #
+ # The namespace/class given will have its options showed on the help
+ # usage. Check invoke_from_option for more information.
+ #
+ # source://thor//lib/thor/group.rb#56
+ def invoke(*names, &block); end
+
+ # Invoke a thor class based on the value supplied by the user to the
+ # given option named "name". A class option must be created before this
+ # method is invoked for each name given.
+ #
+ # ==== Examples
+ #
+ # class GemGenerator < Thor::Group
+ # class_option :test_framework, :type => :string
+ # invoke_from_option :test_framework
+ # end
+ #
+ # ==== Boolean options
+ #
+ # In some cases, you want to invoke a thor class if some option is true or
+ # false. This is automatically handled by invoke_from_option. Then the
+ # option name is used to invoke the generator.
+ #
+ # ==== Preparing for invocation
+ #
+ # In some cases you want to customize how a specified hook is going to be
+ # invoked. You can do that by overwriting the class method
+ # prepare_for_invocation. The class method must necessarily return a klass
+ # and an optional command.
+ #
+ # ==== Custom invocations
+ #
+ # You can also supply a block to customize how the option is going to be
+ # invoked. The block receives two parameters, an instance of the current
+ # class and the klass to be invoked.
+ #
+ # source://thor//lib/thor/group.rb#110
+ def invoke_from_option(*names, &block); end
+
+ # Returns commands ready to be printed.
+ #
+ # source://thor//lib/thor/group.rb#199
+ def printable_commands(*_arg0); end
+
+ # Returns commands ready to be printed.
+ #
+ # source://thor//lib/thor/group.rb#199
+ def printable_tasks(*_arg0); end
+
+ # Remove a previously added invocation.
+ #
+ # ==== Examples
+ #
+ # remove_invocation :test_framework
+ #
+ # source://thor//lib/thor/group.rb#149
+ def remove_invocation(*names); end
+
+ protected
+
+ # The banner for this class. You can customize it if you are invoking the
+ # thor class by another ways which is not the Thor::Runner.
+ #
+ # source://thor//lib/thor/group.rb#238
+ def banner; end
+
+ # source://thor//lib/thor/group.rb#248
+ def baseclass; end
+
+ # source://thor//lib/thor/group.rb#252
+ def create_command(meth); end
+
+ # source://thor//lib/thor/group.rb#252
+ def create_task(meth); end
+
+ # The method responsible for dispatching given the args.
+ #
+ # @yield [instance]
+ #
+ # source://thor//lib/thor/group.rb#217
+ def dispatch(command, given_args, given_opts, config); end
+
+ # Represents the whole class as a command.
+ #
+ # source://thor//lib/thor/group.rb#243
+ def self_command; end
+
+ # Represents the whole class as a command.
+ #
+ # source://thor//lib/thor/group.rb#243
+ def self_task; end
+ end
+end
+
+# Shortcuts for help.
+#
+# source://thor//lib/thor/base.rb#17
+Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
+
+# A command that is hidden in help messages but still invocable.
+#
+# source://thor//lib/thor/command.rb#129
+class Thor::HiddenCommand < ::Thor::Command
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/command.rb#130
+ def hidden?; end
+end
+
+# source://thor//lib/thor/command.rb#134
+Thor::HiddenTask = Thor::HiddenCommand
+
+# source://thor//lib/thor/invocation.rb#2
+module Thor::Invocation
+ mixes_in_class_methods ::Thor::Invocation::ClassMethods
+
+ # Make initializer aware of invocations and the initialization args.
+ #
+ # source://thor//lib/thor/invocation.rb#23
+ def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
+
+ # Make the current command chain accessible with in a Thor-(sub)command
+ #
+ # source://thor//lib/thor/invocation.rb#30
+ def current_command_chain; end
+
+ # Receives a name and invokes it. The name can be a string (either "command" or
+ # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+ # command cannot be guessed by name, it can also be supplied as second argument.
+ #
+ # You can also supply the arguments, options and configuration values for
+ # the command to be invoked, if none is given, the same values used to
+ # initialize the invoker are used to initialize the invoked.
+ #
+ # When no name is given, it will invoke the default command of the current class.
+ #
+ # ==== Examples
+ #
+ # class A < Thor
+ # def foo
+ # invoke :bar
+ # invoke "b:hello", ["Erik"]
+ # end
+ #
+ # def bar
+ # invoke "b:hello", ["Erik"]
+ # end
+ # end
+ #
+ # class B < Thor
+ # def hello(name)
+ # puts "hello #{name}"
+ # end
+ # end
+ #
+ # You can notice that the method "foo" above invokes two commands: "bar",
+ # which belongs to the same class and "hello" which belongs to the class B.
+ #
+ # By using an invocation system you ensure that a command is invoked only once.
+ # In the example above, invoking "foo" will invoke "b:hello" just once, even
+ # if it's invoked later by "bar" method.
+ #
+ # When class A invokes class B, all arguments used on A initialization are
+ # supplied to B. This allows lazy parse of options. Let's suppose you have
+ # some rspec commands:
+ #
+ # class Rspec < Thor::Group
+ # class_option :mock_framework, :type => :string, :default => :rr
+ #
+ # def invoke_mock_framework
+ # invoke "rspec:#{options[:mock_framework]}"
+ # end
+ # end
+ #
+ # As you noticed, it invokes the given mock framework, which might have its
+ # own options:
+ #
+ # class Rspec::RR < Thor::Group
+ # class_option :style, :type => :string, :default => :mock
+ # end
+ #
+ # Since it's not rspec concern to parse mock framework options, when RR
+ # is invoked all options are parsed again, so RR can extract only the options
+ # that it's going to use.
+ #
+ # If you want Rspec::RR to be initialized with its own set of options, you
+ # have to do that explicitly:
+ #
+ # invoke "rspec:rr", [], :style => :foo
+ #
+ # Besides giving an instance, you can also give a class to invoke:
+ #
+ # invoke Rspec::RR, [], :style => :foo
+ #
+ # source://thor//lib/thor/invocation.rb#102
+ def invoke(name = T.unsafe(nil), *args); end
+
+ # Invoke all commands for the current instance.
+ #
+ # source://thor//lib/thor/invocation.rb#133
+ def invoke_all; end
+
+ # Invoke the given command if the given args.
+ #
+ # source://thor//lib/thor/invocation.rb#122
+ def invoke_command(command, *args); end
+
+ # Invoke the given command if the given args.
+ #
+ # source://thor//lib/thor/invocation.rb#122
+ def invoke_task(command, *args); end
+
+ # Invokes using shell padding.
+ #
+ # source://thor//lib/thor/invocation.rb#138
+ def invoke_with_padding(*args); end
+
+ protected
+
+ # Initialize klass using values stored in the @_initializer.
+ #
+ # source://thor//lib/thor/invocation.rb#166
+ def _parse_initialization_options(args, opts, config); end
+
+ # This method simply retrieves the class and command to be invoked.
+ # If the name is nil or the given name is a command in the current class,
+ # use the given name and return self as class. Otherwise, call
+ # prepare_for_invocation in the current class.
+ #
+ # source://thor//lib/thor/invocation.rb#153
+ def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
+
+ # This method simply retrieves the class and command to be invoked.
+ # If the name is nil or the given name is a command in the current class,
+ # use the given name and return self as class. Otherwise, call
+ # prepare_for_invocation in the current class.
+ #
+ # source://thor//lib/thor/invocation.rb#153
+ def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
+
+ # Configuration values that are shared between invocations.
+ #
+ # source://thor//lib/thor/invocation.rb#145
+ def _shared_configuration; end
+
+ class << self
+ # source://thor//lib/thor/invocation.rb#3
+ def included(base); end
+ end
+end
+
+# source://thor//lib/thor/invocation.rb#8
+module Thor::Invocation::ClassMethods
+ # This method is responsible for receiving a name and find the proper
+ # class and command for it. The key is an optional parameter which is
+ # available only in class methods invocations (i.e. in Thor::Group).
+ #
+ # source://thor//lib/thor/invocation.rb#12
+ def prepare_for_invocation(key, name); end
+end
+
+# Raised when a command was found, but not invoked properly.
+#
+# source://thor//lib/thor/error.rb#62
+class Thor::InvocationError < ::Thor::Error; end
+
+# source://thor//lib/thor/line_editor/basic.rb#2
+module Thor::LineEditor
+ class << self
+ # source://thor//lib/thor/line_editor.rb#10
+ def best_available; end
+
+ # source://thor//lib/thor/line_editor.rb#6
+ def readline(prompt, options = T.unsafe(nil)); end
+ end
+end
+
+# source://thor//lib/thor/line_editor/basic.rb#3
+class Thor::LineEditor::Basic
+ # @return [Basic] a new instance of Basic
+ #
+ # source://thor//lib/thor/line_editor/basic.rb#10
+ def initialize(prompt, options); end
+
+ # Returns the value of attribute options.
+ #
+ # source://thor//lib/thor/line_editor/basic.rb#4
+ def options; end
+
+ # Returns the value of attribute prompt.
+ #
+ # source://thor//lib/thor/line_editor/basic.rb#4
+ def prompt; end
+
+ # source://thor//lib/thor/line_editor/basic.rb#15
+ def readline; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/line_editor/basic.rb#32
+ def echo?; end
+
+ # source://thor//lib/thor/line_editor/basic.rb#22
+ def get_input; end
+
+ class << self
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/line_editor/basic.rb#6
+ def available?; end
+ end
+end
+
+# source://thor//lib/thor/line_editor/readline.rb#3
+class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
+ # source://thor//lib/thor/line_editor/readline.rb#13
+ def readline; end
+
+ private
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/line_editor/readline.rb#28
+ def add_to_history?; end
+
+ # source://thor//lib/thor/line_editor/readline.rb#42
+ def completion_options; end
+
+ # source://thor//lib/thor/line_editor/readline.rb#32
+ def completion_proc; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/line_editor/readline.rb#46
+ def use_path_completion?; end
+
+ class << self
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/line_editor/readline.rb#4
+ def available?; end
+ end
+end
+
+# source://thor//lib/thor/line_editor/readline.rb#50
+class Thor::LineEditor::Readline::PathCompletion
+ # @return [PathCompletion] a new instance of PathCompletion
+ #
+ # source://thor//lib/thor/line_editor/readline.rb#54
+ def initialize(text); end
+
+ # source://thor//lib/thor/line_editor/readline.rb#58
+ def matches; end
+
+ private
+
+ # source://thor//lib/thor/line_editor/readline.rb#68
+ def absolute_matches; end
+
+ # source://thor//lib/thor/line_editor/readline.rb#82
+ def base_path; end
+
+ # source://thor//lib/thor/line_editor/readline.rb#78
+ def glob_pattern; end
+
+ # source://thor//lib/thor/line_editor/readline.rb#64
+ def relative_matches; end
+
+ # Returns the value of attribute text.
+ #
+ # source://thor//lib/thor/line_editor/readline.rb#51
+ def text; end
+end
+
+# source://thor//lib/thor/error.rb#98
+class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/nested_context.rb#2
+class Thor::NestedContext
+ # @return [NestedContext] a new instance of NestedContext
+ #
+ # source://thor//lib/thor/nested_context.rb#3
+ def initialize; end
+
+ # source://thor//lib/thor/nested_context.rb#7
+ def enter; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/nested_context.rb#15
+ def entered?; end
+
+ private
+
+ # source://thor//lib/thor/nested_context.rb#25
+ def pop; end
+
+ # source://thor//lib/thor/nested_context.rb#21
+ def push; end
+end
+
+# source://thor//lib/thor/parser/option.rb#2
+class Thor::Option < ::Thor::Argument
+ # @return [Option] a new instance of Option
+ #
+ # source://thor//lib/thor/parser/option.rb#7
+ def initialize(name, options = T.unsafe(nil)); end
+
+ # Returns the value of attribute aliases.
+ #
+ # source://thor//lib/thor/parser/option.rb#3
+ def aliases; end
+
+ # source://thor//lib/thor/parser/option.rb#99
+ def aliases_for_usage; end
+
+ # source://thor//lib/thor/parser/option.rb#118
+ def array?; end
+
+ # source://thor//lib/thor/parser/option.rb#118
+ def boolean?; end
+
+ # Returns the value of attribute group.
+ #
+ # source://thor//lib/thor/parser/option.rb#3
+ def group; end
+
+ # source://thor//lib/thor/parser/option.rb#118
+ def hash?; end
+
+ # Returns the value of attribute hide.
+ #
+ # source://thor//lib/thor/parser/option.rb#3
+ def hide; end
+
+ # source://thor//lib/thor/parser/option.rb#79
+ def human_name; end
+
+ # Returns the value of attribute lazy_default.
+ #
+ # source://thor//lib/thor/parser/option.rb#3
+ def lazy_default; end
+
+ # source://thor//lib/thor/parser/option.rb#118
+ def numeric?; end
+
+ # Returns the value of attribute repeatable.
+ #
+ # source://thor//lib/thor/parser/option.rb#3
+ def repeatable; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/option.rb#107
+ def show_default?; end
+
+ # source://thor//lib/thor/parser/option.rb#118
+ def string?; end
+
+ # source://thor//lib/thor/parser/option.rb#75
+ def switch_name; end
+
+ # source://thor//lib/thor/parser/option.rb#83
+ def usage(padding = T.unsafe(nil)); end
+
+ protected
+
+ # source://thor//lib/thor/parser/option.rb#168
+ def dasherize(str); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/option.rb#160
+ def dasherized?; end
+
+ # source://thor//lib/thor/parser/option.rb#164
+ def undasherize(str); end
+
+ # @raise [ArgumentError]
+ #
+ # source://thor//lib/thor/parser/option.rb#126
+ def validate!; end
+
+ # source://thor//lib/thor/parser/option.rb#131
+ def validate_default_type!; end
+
+ private
+
+ # source://thor//lib/thor/parser/option.rb#174
+ def normalize_aliases(aliases); end
+
+ class << self
+ # This parse quick options given as method_options. It makes several
+ # assumptions, but you can be more specific using the option method.
+ #
+ # parse :foo => "bar"
+ # #=> Option foo with default value bar
+ #
+ # parse [:foo, :baz] => "bar"
+ # #=> Option foo with default value bar and alias :baz
+ #
+ # parse :foo => :required
+ # #=> Required option foo without default value
+ #
+ # parse :foo => 2
+ # #=> Option foo with default value 2 and type numeric
+ #
+ # parse :foo => :numeric
+ # #=> Option foo without default value and type numeric
+ #
+ # parse :foo => true
+ # #=> Option foo with default value true and type boolean
+ #
+ # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+ # is given a default type is assumed. This default type accepts arguments as
+ # string (--foo=value) or booleans (just --foo).
+ #
+ # By default all options are optional, unless :required is given.
+ #
+ # source://thor//lib/thor/parser/option.rb#45
+ def parse(key, value); end
+ end
+end
+
+# source://thor//lib/thor/parser/option.rb#5
+Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+# source://thor//lib/thor/parser/options.rb#2
+class Thor::Options < ::Thor::Arguments
+ # Takes a hash of Thor::Option and a hash with defaults.
+ #
+ # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+ # an unknown option or a regular argument.
+ #
+ # @return [Options] a new instance of Options
+ #
+ # source://thor//lib/thor/parser/options.rb#32
+ def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil), relations = T.unsafe(nil)); end
+
+ # source://thor//lib/thor/parser/options.rb#156
+ def check_at_least_one!; end
+
+ # source://thor//lib/thor/parser/options.rb#144
+ def check_exclusive!; end
+
+ # @raise [UnknownArgumentError]
+ #
+ # source://thor//lib/thor/parser/options.rb#168
+ def check_unknown!; end
+
+ # source://thor//lib/thor/parser/options.rb#89
+ def parse(args); end
+
+ # source://thor//lib/thor/parser/options.rb#65
+ def peek; end
+
+ # source://thor//lib/thor/parser/options.rb#61
+ def remaining; end
+
+ # source://thor//lib/thor/parser/options.rb#79
+ def shift; end
+
+ # source://thor//lib/thor/parser/options.rb#84
+ def unshift(arg, is_value: T.unsafe(nil)); end
+
+ protected
+
+ # source://thor//lib/thor/parser/options.rb#189
+ def assign_result!(option, result); end
+
+ # Check if the current value in peek is a registered switch.
+ #
+ # Two booleans are returned. The first is true if the current value
+ # starts with a hyphen; the second is true if it is a registered switch.
+ #
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/options.rb#203
+ def current_is_switch?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/options.rb#215
+ def current_is_switch_formatted?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/options.rb#225
+ def current_is_value?; end
+
+ # Option names changes to swith name or human name
+ #
+ # source://thor//lib/thor/parser/options.rb#179
+ def names_to_switch_names(names = T.unsafe(nil)); end
+
+ # Check if the given argument is actually a shortcut.
+ #
+ # source://thor//lib/thor/parser/options.rb#244
+ def normalize_switch(arg); end
+
+ # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+ #
+ # source://thor//lib/thor/parser/options.rb#255
+ def parse_boolean(switch); end
+
+ # Parse the value at the peek analyzing if it requires an input or not.
+ #
+ # source://thor//lib/thor/parser/options.rb#273
+ def parse_peek(switch, option); end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/options.rb#248
+ def parsing_options?; end
+
+ # @return [Boolean]
+ #
+ # source://thor//lib/thor/parser/options.rb#230
+ def switch?(arg); end
+
+ # source://thor//lib/thor/parser/options.rb#234
+ def switch_option(arg); end
+
+ class << self
+ # Receives a hash and makes it switches.
+ #
+ # source://thor//lib/thor/parser/options.rb#11
+ def to_switches(options); end
+ end
+end
+
+# source://thor//lib/thor/parser/options.rb#5
+Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#3
+Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#8
+Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
+
+# source://thor//lib/thor/parser/options.rb#7
+Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/parser/options.rb#4
+Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
+
+# Allow either -x -v or -xv style for single char args
+#
+# source://thor//lib/thor/parser/options.rb#6
+Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
+
+# source://thor//lib/thor/error.rb#95
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
+
+# source://thor//lib/thor/util.rb#4
+module Thor::Sandbox; end
+
+# source://thor//lib/thor/shell.rb#23
+module Thor::Shell
+ # Add shell to initialize config values.
+ #
+ # ==== Configuration
+ # shell