diff --git a/Gemfile.lock b/Gemfile.lock index da982acb7..75f803dac 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -1,8 +1,8 @@ GIT remote: https://github.com/Shopify/tapioca.git - revision: f29ea5d1cb6051bb1af4f867ff4bab39992809c3 + revision: 6c258b4291a2435c93474cabfa89d94fcdbfd009 specs: - tapioca (0.13.3) + tapioca (0.14.3) bundler (>= 2.2.25) netrc (>= 0.11.0) parallel (>= 1.21.0) @@ -142,7 +142,7 @@ GEM racc pg (1.5.6) polyfill (1.9.0) - prism (0.24.0) + prism (0.29.0) pry (0.14.2) coderay (~> 1.1) method_source (~> 1.0) @@ -174,8 +174,8 @@ GEM zeitwerk (~> 2.6) rainbow (3.1.1) rake (13.2.1) - rbi (0.1.10) - prism (>= 0.18.0, < 0.25) + rbi (0.1.13) + prism (>= 0.18.0, < 1.0.0) sorbet-runtime (>= 0.5.9204) rbs (3.2.1) rchardet (1.8.0) @@ -246,7 +246,7 @@ GEM rbs (~> 3.0) sorbet-runtime yard - spoom (1.3.0) + spoom (1.3.2) erubi (>= 1.10.0) prism (>= 0.19.0) sorbet-static-and-runtime (>= 0.5.10187) diff --git a/sorbet/rbi/gems/prism@0.24.0.rbi b/sorbet/rbi/gems/prism@0.24.0.rbi deleted file mode 100644 index 9ceb30ba7..000000000 --- a/sorbet/rbi/gems/prism@0.24.0.rbi +++ /dev/null @@ -1,10668 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `prism` gem. -# Please instead update this file by running `bin/tapioca gem prism`. - -# =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 - -module Prism - class << self - def dump(*_arg0); end - def dump_file(*_arg0); end - def lex(*_arg0); end - def lex_compat(source, **options); end - def lex_file(*_arg0); end - def lex_ripper(source); end - def load(source, serialized); end - def parse(*_arg0); end - def parse_comments(*_arg0); end - def parse_failure?(source, **options); end - def parse_file(*_arg0); end - def parse_file_comments(*_arg0); end - def parse_file_failure?(filepath, **options); end - def parse_file_success?(*_arg0); end - def parse_lex(*_arg0); end - def parse_lex_file(*_arg0); end - def parse_success?(*_arg0); end - end -end - -class Prism::AliasGlobalVariableNode < ::Prism::Node - def initialize(source, new_name, old_name, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AliasGlobalVariableNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def new_name; end - - sig { returns(Prism::Node) } - def old_name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::AliasMethodNode < ::Prism::Node - def initialize(source, new_name, old_name, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AliasMethodNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def new_name; end - - sig { returns(Prism::Node) } - def old_name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::AlternationPatternNode < ::Prism::Node - def initialize(source, left, right, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AlternationPatternNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def left; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def right; end - - def type; end - - class << self - def type; end - end -end - -class Prism::AndNode < ::Prism::Node - def initialize(source, left, right, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AndNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def left; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def right; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ArgumentsNode < ::Prism::Node - def initialize(source, flags, arguments, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[Prism::Node]) } - def arguments; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T::Boolean) } - def contains_keyword_splat?; end - - sig { params(params: T.untyped).returns(Prism::ArgumentsNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -# Flags for arguments nodes. -module Prism::ArgumentsNodeFlags; end - -Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer) - -class Prism::ArrayNode < ::Prism::Node - def initialize(source, flags, elements, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T::Boolean) } - def contains_splat?; end - - sig { params(params: T.untyped).returns(Prism::ArrayNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Array[Prism::Node]) } - def elements; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -# Flags for array nodes. -module Prism::ArrayNodeFlags; end - -Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) - -class Prism::ArrayPatternNode < ::Prism::Node - def initialize(source, constant, requireds, rest, posts, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::Node)) } - def constant; end - - sig { params(params: T.untyped).returns(Prism::ArrayPatternNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def posts; end - - sig { returns(T::Array[Prism::Node]) } - def requireds; end - - sig { returns(T.nilable(Prism::Node)) } - def rest; end - - def type; end - - class << self - def type; end - end -end - -class Prism::AssocNode < ::Prism::Node - def initialize(source, key, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AssocNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def key; end - - sig { returns(T.nilable(String)) } - def operator; end - - sig { returns(T.nilable(Prism::Location)) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::AssocSplatNode < ::Prism::Node - def initialize(source, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::AssocSplatNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(T.nilable(Prism::Node)) } - def value; end - - class << self - def type; end - end -end - -Prism::BACKEND = T.let(T.unsafe(nil), Symbol) - -class Prism::BackReferenceReadNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BackReferenceReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::BasicVisitor - sig { params(node: T.nilable(Prism::Node)).void } - def visit(node); end - - sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void } - def visit_all(nodes); end - - sig { params(node: Prism::Node).void } - def visit_child_nodes(node); end -end - -class Prism::BeginNode < ::Prism::Node - def initialize(source, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(String)) } - def begin_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def begin_keyword_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BeginNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(Prism::ElseNode)) } - def else_clause; end - - sig { returns(T.nilable(String)) } - def end_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def end_keyword_loc; end - - sig { returns(T.nilable(Prism::EnsureNode)) } - def ensure_clause; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::RescueNode)) } - def rescue_clause; end - - def set_newline_flag(newline_marked); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::BlockArgumentNode < ::Prism::Node - def initialize(source, expression, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BlockArgumentNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(Prism::Node)) } - def expression; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::BlockLocalVariableNode < ::Prism::Node - def initialize(source, flags, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BlockLocalVariableNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::BlockNode < ::Prism::Node - def initialize(source, locals, parameters, body, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BlockNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def parameters; end - - def type; end - - class << self - def type; end - end -end - -class Prism::BlockParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BlockParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(Symbol)) } - def name; end - - sig { returns(T.nilable(Prism::Location)) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::BlockParametersNode < ::Prism::Node - def initialize(source, parameters, locals, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BlockParametersNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Prism::Node]) } - def locals; end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T.nilable(Prism::ParametersNode)) } - def parameters; end - - def type; end - - class << self - def type; end - end -end - -class Prism::BreakNode < ::Prism::Node - def initialize(source, arguments, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::BreakNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::CallAndWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CallAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def message; end - - sig { returns(T.nilable(Prism::Location)) } - def message_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Symbol) } - def read_name; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - sig { returns(Symbol) } - def write_name; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::CallNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CallNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def message; end - - sig { returns(T.nilable(Prism::Location)) } - def message_loc; end - - sig { returns(Symbol) } - def name; end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -# Flags for call nodes. -module Prism::CallNodeFlags; end - -Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer) -Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer) -Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer) -Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) - -class Prism::CallOperatorWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CallOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def message; end - - sig { returns(T.nilable(Prism::Location)) } - def message_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Symbol) } - def read_name; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - sig { returns(Symbol) } - def write_name; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::CallOrWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CallOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def message; end - - sig { returns(T.nilable(Prism::Location)) } - def message_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Symbol) } - def read_name; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - sig { returns(Symbol) } - def write_name; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::CallTargetNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, name, message_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(String) } - def call_operator; end - - sig { returns(Prism::Location) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CallTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def message; end - - sig { returns(Prism::Location) } - def message_loc; end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Node) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::CapturePatternNode < ::Prism::Node - def initialize(source, value, target, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::CapturePatternNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def target; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::CaseMatchNode < ::Prism::Node - def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(String) } - def case_keyword; end - - sig { returns(Prism::Location) } - def case_keyword_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T::Array[Prism::Node]) } - def conditions; end - - sig { returns(T.nilable(Prism::ElseNode)) } - def consequent; end - - sig { params(params: T.untyped).returns(Prism::CaseMatchNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def predicate; end - - def type; end - - class << self - def type; end - end -end - -class Prism::CaseNode < ::Prism::Node - def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(String) } - def case_keyword; end - - sig { returns(Prism::Location) } - def case_keyword_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T::Array[Prism::Node]) } - def conditions; end - - sig { returns(T.nilable(Prism::ElseNode)) } - def consequent; end - - sig { params(params: T.untyped).returns(Prism::CaseNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def predicate; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ClassNode < ::Prism::Node - def initialize(source, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def class_keyword; end - - sig { returns(Prism::Location) } - def class_keyword_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(Prism::Node) } - def constant_path; end - - sig { params(params: T.untyped).returns(Prism::ClassNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - sig { returns(T.nilable(String)) } - def inheritance_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def inheritance_operator_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(Symbol) } - def name; end - - sig { returns(T.nilable(Prism::Node)) } - def superclass; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ClassVariableAndWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ClassVariableOperatorWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, operator, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ClassVariableOrWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ClassVariableReadNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ClassVariableTargetNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ClassVariableWriteNode < ::Prism::Node - def initialize(source, name, name_loc, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ClassVariableWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(T.nilable(String)) } - def operator; end - - sig { returns(T.nilable(Prism::Location)) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::Comment - def initialize(location); end - - def deconstruct_keys(keys); end - - sig { returns(Prism::Location) } - def location; end - - sig { returns(T::Boolean) } - def trailing?; end -end - -class Prism::Compiler - def visit(node); end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_all(nodes); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_child_nodes(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end -end - -class Prism::ConstantAndWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantOperatorWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, operator, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantOrWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantPathAndWriteNode < ::Prism::Node - def initialize(source, target, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::ConstantPathNode) } - def target; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantPathNode < ::Prism::Node - def initialize(source, parent, child, delimiter_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(Prism::Node) } - def child; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def delimiter; end - - sig { returns(Prism::Location) } - def delimiter_loc; end - - def full_name; end - def full_name_parts; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def parent; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end - -class Prism::ConstantPathOperatorWriteNode < ::Prism::Node - def initialize(source, target, operator_loc, value, operator, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::ConstantPathNode) } - def target; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantPathOrWriteNode < ::Prism::Node - def initialize(source, target, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::ConstantPathNode) } - def target; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantPathTargetNode < ::Prism::Node - def initialize(source, parent, child, delimiter_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(Prism::Node) } - def child; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def delimiter; end - - sig { returns(Prism::Location) } - def delimiter_loc; end - - def full_name; end - def full_name_parts; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def parent; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ConstantPathWriteNode < ::Prism::Node - def initialize(source, target, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantPathWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::ConstantPathNode) } - def target; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ConstantReadNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 full_name; end - def full_name_parts; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ConstantTargetNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 full_name; end - def full_name_parts; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ConstantWriteNode < ::Prism::Node - def initialize(source, name, name_loc, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ConstantWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::DATAComment < Prism::Comment; end - -module Prism::DSL - private - - def AliasGlobalVariableNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def AliasMethodNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def AlternationPatternNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def AndNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ArgumentsNode(flags, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ArrayNode(flags, elements, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def AssocNode(key, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def AssocSplatNode(value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BackReferenceReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BlockArgumentNode(expression, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BlockLocalVariableNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BlockNode(locals, parameters, body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BlockParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BlockParametersNode(parameters, locals, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def BreakNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CapturePatternNode(value, target, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ClassVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantOperatorWriteNode(name, name_loc, operator_loc, value, operator, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathAndWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathNode(parent, child, delimiter_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathOrWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathTargetNode(parent, child, delimiter_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantPathWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ConstantWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ElseNode(else_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def EmbeddedStatementsNode(opening_loc, statements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def EmbeddedVariableNode(operator_loc, variable, source = T.unsafe(nil), location = T.unsafe(nil)); end - def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def FalseNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def FlipFlopNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def FloatNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ForwardingArgumentsNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def ForwardingParameterNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def ForwardingSuperNode(block, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def GlobalVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def HashNode(opening_loc, elements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ImaginaryNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ImplicitNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ImplicitRestNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def InNode(pattern, statements, in_loc, then_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InstanceVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def IntegerNode(flags, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InterpolatedStringNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InterpolatedSymbolNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def InterpolatedXStringNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def KeywordHashNode(flags, elements, source = T.unsafe(nil), location = T.unsafe(nil)); end - def KeywordRestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableReadNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableTargetNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end - def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end - def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MatchPredicateNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MatchRequiredNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MatchWriteNode(call, targets, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MissingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def NextNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def NilNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def NoKeywordsParameterNode(operator_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def NumberedParametersNode(maximum, source = T.unsafe(nil), location = T.unsafe(nil)); end - def NumberedReferenceReadNode(number, source = T.unsafe(nil), location = T.unsafe(nil)); end - def OptionalKeywordParameterNode(flags, name, name_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def OptionalParameterNode(flags, name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end - def OrNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ParenthesesNode(body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def PinnedVariableNode(variable, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def ProgramNode(locals, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RangeNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RationalNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RedoNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RequiredKeywordParameterNode(flags, name, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RequiredParameterNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RescueModifierNode(expression, keyword_loc, rescue_expression, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def RetryNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def ReturnNode(keyword_loc, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end - def SelfNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def SourceEncodingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def SourceFileNode(filepath, source = T.unsafe(nil), location = T.unsafe(nil)); end - def SourceLineNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def SplatNode(operator_loc, expression, source = T.unsafe(nil), location = T.unsafe(nil)); end - def StatementsNode(body, source = T.unsafe(nil), location = T.unsafe(nil)); end - def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end - def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end - def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end - def TrueNode(source = T.unsafe(nil), location = T.unsafe(nil)); end - def UndefNode(names, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end - def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end - def WhenNode(keyword_loc, conditions, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end - def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end - def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end - def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end -end - -module Prism::Debug - class << self - def cruby_locals(source); end - def format_errors(_arg0, _arg1); end - def inspect_node(_arg0); end - def memsize(_arg0); end - def named_captures(_arg0); end - def newlines(source); end - def prism_locals(source); end - def profile_file(_arg0); end - end -end - -Prism::Debug::AnonymousLocal = T.let(T.unsafe(nil), Object) - -class Prism::Debug::ISeq - def initialize(parts); end - - def each_child; end - def instructions; end - def local_table; end - def parts; end - def type; end -end - -class Prism::DefNode < ::Prism::Node - def initialize(source, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::DefNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def def_keyword; end - - sig { returns(Prism::Location) } - def def_keyword_loc; end - - sig { returns(T.nilable(String)) } - def end_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def end_keyword_loc; end - - sig { returns(T.nilable(String)) } - def equal; end - - sig { returns(T.nilable(Prism::Location)) } - def equal_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(T.nilable(String)) } - def operator; end - - sig { returns(T.nilable(Prism::Location)) } - def operator_loc; end - - sig { returns(T.nilable(Prism::ParametersNode)) } - def parameters; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::DefinedNode < ::Prism::Node - def initialize(source, lparen_loc, value, rparen_loc, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::DefinedNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::DesugarAndWriteNode - def initialize(node, source, read_class, write_class, *arguments); end - - def arguments; end - def compile; end - def node; end - def read_class; end - def source; end - def write_class; end -end - -class Prism::DesugarCompiler < ::Prism::MutationCompiler - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end -end - -class Prism::DesugarOperatorWriteNode - def initialize(node, source, read_class, write_class, *arguments); end - - def arguments; end - def compile; end - def node; end - def read_class; end - def source; end - def write_class; end -end - -class Prism::DesugarOrWriteDefinedNode - def initialize(node, source, read_class, write_class, *arguments); end - - def arguments; end - def compile; end - def node; end - def read_class; end - def source; end - def write_class; end -end - -class Prism::DesugarOrWriteNode - def initialize(node, source, read_class, write_class, *arguments); end - - def arguments; end - def compile; end - def node; end - def read_class; end - def source; end - def write_class; end -end - -class Prism::Dispatcher < ::Prism::Visitor - def initialize; end - - def dispatch(node); end - def dispatch_once(node); end - def listeners; end - def register(listener, *events); end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end -end - -class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor - def initialize(listeners); end - - def listeners; end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end -end - -class Prism::DotVisitor < ::Prism::Visitor - def initialize; end - - def digraph; end - def to_dot; end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end - - private - - def arguments_node_flags_inspect(node); end - def array_node_flags_inspect(node); end - def call_node_flags_inspect(node); end - def encoding_flags_inspect(node); end - def integer_base_flags_inspect(node); end - def keyword_hash_node_flags_inspect(node); end - def location_inspect(location); end - def loop_flags_inspect(node); end - def node_id(node); end - def parameter_flags_inspect(node); end - def range_flags_inspect(node); end - def regular_expression_flags_inspect(node); end - def string_flags_inspect(node); end - def symbol_flags_inspect(node); end -end - -class Prism::DotVisitor::Digraph - def initialize; end - - def edge(value); end - def edges; end - def node(value); end - def nodes; end - def to_dot; end - def waypoint(value); end - def waypoints; end -end - -class Prism::DotVisitor::Field - def initialize(name, value, port); end - - def name; end - def port; end - def to_dot; end - def value; end -end - -class Prism::DotVisitor::Table - def initialize(name); end - - def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end - def fields; end - def name; end - def to_dot; end -end - -class Prism::ElseNode < ::Prism::Node - def initialize(source, else_keyword_loc, statements, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ElseNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def else_keyword; end - - sig { returns(Prism::Location) } - def else_keyword_loc; end - - sig { returns(T.nilable(String)) } - def end_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def end_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::EmbDocComment < ::Prism::Comment - def inspect; end - def trailing?; end -end - -class Prism::EmbeddedStatementsNode < ::Prism::Node - def initialize(source, opening_loc, statements, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::EmbeddedStatementsNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::EmbeddedVariableNode < ::Prism::Node - def initialize(source, operator_loc, variable, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::EmbeddedVariableNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def variable; end - - class << self - def type; end - end -end - -# Flags for nodes that have unescaped content. -module Prism::EncodingFlags; end - -Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) - -class Prism::EnsureNode < ::Prism::Node - def initialize(source, ensure_keyword_loc, statements, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::EnsureNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - sig { returns(String) } - def ensure_keyword; end - - sig { returns(Prism::Location) } - def ensure_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::FalseNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::FalseNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::FindPatternNode < ::Prism::Node - def initialize(source, constant, left, requireds, right, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::Node)) } - def constant; end - - sig { params(params: T.untyped).returns(Prism::FindPatternNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def left; end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def requireds; end - - sig { returns(Prism::Node) } - def right; end - - def type; end - - class << self - def type; end - end -end - -class Prism::FlipFlopNode < ::Prism::Node - def initialize(source, flags, left, right, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::FlipFlopNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def exclude_end?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def left; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def right; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::FloatNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::FloatNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - def value; end - - class << self - def type; end - end -end - -class Prism::ForNode < ::Prism::Node - def initialize(source, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(Prism::Node) } - def collection; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ForNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(String)) } - def do_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def do_keyword_loc; end - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - sig { returns(String) } - def for_keyword; end - - sig { returns(Prism::Location) } - def for_keyword_loc; end - - sig { returns(String) } - def in_keyword; end - - sig { returns(Prism::Location) } - def in_keyword_loc; end - - sig { returns(Prism::Node) } - def index; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ForwardingArgumentsNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ForwardingArgumentsNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::ForwardingParameterNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ForwardingParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::ForwardingSuperNode < ::Prism::Node - def initialize(source, block, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::BlockNode)) } - def block; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ForwardingSuperNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableAndWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, operator, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableOrWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableReadNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableTargetNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::GlobalVariableWriteNode < ::Prism::Node - def initialize(source, name, name_loc, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::GlobalVariableWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::HashNode < ::Prism::Node - def initialize(source, opening_loc, elements, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::HashNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Array[Prism::Node]) } - def elements; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::HashPatternNode < ::Prism::Node - def initialize(source, constant, elements, rest, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::Node)) } - def constant; end - - sig { params(params: T.untyped).returns(Prism::HashPatternNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Array[Prism::Node]) } - def elements; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def rest; end - - def type; end - - class << self - def type; end - end -end - -module Prism::HeredocQuery - def heredoc?; end -end - -class Prism::IfNode < ::Prism::Node - def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::Node)) } - def consequent; end - - sig { params(params: T.untyped).returns(Prism::IfNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(String)) } - def end_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def end_keyword_loc; end - - sig { returns(T.nilable(String)) } - def if_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def if_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def predicate; end - - def set_newline_flag(newline_marked); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - sig { returns(T.nilable(String)) } - def then_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def then_keyword_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ImaginaryNode < ::Prism::Node - def initialize(source, numeric, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ImaginaryNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def numeric; end - - def type; end - def value; end - - class << self - def type; end - end -end - -class Prism::ImplicitNode < ::Prism::Node - def initialize(source, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ImplicitNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::ImplicitRestNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ImplicitRestNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::InNode < ::Prism::Node - def initialize(source, pattern, statements, in_loc, then_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def in; end - - sig { returns(Prism::Location) } - def in_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def pattern; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - sig { returns(T.nilable(String)) } - def then; end - - sig { returns(T.nilable(Prism::Location)) } - def then_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::IndexAndWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::IndexAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::IndexOperatorWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::IndexOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::IndexOrWriteNode < ::Prism::Node - def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T.nilable(String)) } - def call_operator; end - - sig { returns(T.nilable(Prism::Location)) } - def call_operator_loc; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::IndexOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::IndexTargetNode < ::Prism::Node - def initialize(source, flags, receiver, opening_loc, arguments, closing_loc, block, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Boolean) } - def attribute_write?; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::IndexTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def ignore_visibility?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(Prism::Node) } - def receiver; end - - sig { returns(T::Boolean) } - def safe_navigation?; end - - def type; end - - sig { returns(T::Boolean) } - def variable_call?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::InlineComment < ::Prism::Comment - def inspect; end - - sig { override.returns(T::Boolean) } - def trailing?; end -end - -class Prism::InstanceVariableAndWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, operator, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::InstanceVariableOrWriteNode < ::Prism::Node - def initialize(source, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::InstanceVariableReadNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::InstanceVariableTargetNode < ::Prism::Node - def initialize(source, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::InstanceVariableWriteNode < ::Prism::Node - def initialize(source, name, name_loc, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InstanceVariableWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -# Flags for integer nodes that correspond to the base of the integer. -module Prism::IntegerBaseFlags; end - -Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer) -Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer) -Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer) -Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer) - -class Prism::IntegerNode < ::Prism::Node - def initialize(source, flags, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def binary?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::IntegerNode) } - def copy(**params); end - - sig { returns(T::Boolean) } - def decimal?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def hexadecimal?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def octal?; end - - def type; end - def value; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::InterpolatedMatchLastLineNode < ::Prism::Node - include ::Prism::RegularExpressionOptions - - def initialize(source, flags, opening_loc, parts, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def ascii_8bit?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InterpolatedMatchLastLineNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def euc_jp?; end - - sig { returns(T::Boolean) } - def extended?; end - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_us_ascii_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - sig { returns(T::Boolean) } - def ignore_case?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def multi_line?; end - - sig { returns(T::Boolean) } - def once?; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def parts; end - - def set_newline_flag(newline_marked); end - def type; end - - sig { returns(T::Boolean) } - def utf_8?; end - - sig { returns(T::Boolean) } - def windows_31j?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::InterpolatedRegularExpressionNode < ::Prism::Node - include ::Prism::RegularExpressionOptions - - def initialize(source, flags, opening_loc, parts, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def ascii_8bit?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InterpolatedRegularExpressionNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def euc_jp?; end - - sig { returns(T::Boolean) } - def extended?; end - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_us_ascii_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - sig { returns(T::Boolean) } - def ignore_case?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def multi_line?; end - - sig { returns(T::Boolean) } - def once?; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def parts; end - - def set_newline_flag(newline_marked); end - def type; end - - sig { returns(T::Boolean) } - def utf_8?; end - - sig { returns(T::Boolean) } - def windows_31j?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::InterpolatedStringNode < ::Prism::Node - include ::Prism::HeredocQuery - - def initialize(source, opening_loc, parts, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InterpolatedStringNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def parts; end - - def set_newline_flag(newline_marked); end - def type; end - - class << self - def type; end - end -end - -class Prism::InterpolatedSymbolNode < ::Prism::Node - def initialize(source, opening_loc, parts, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InterpolatedSymbolNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def parts; end - - def set_newline_flag(newline_marked); end - def type; end - - class << self - def type; end - end -end - -class Prism::InterpolatedXStringNode < ::Prism::Node - include ::Prism::HeredocQuery - - def initialize(source, opening_loc, parts, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::InterpolatedXStringNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T::Array[Prism::Node]) } - def parts; end - - def set_newline_flag(newline_marked); end - def type; end - - class << self - def type; end - end -end - -class Prism::KeywordHashNode < ::Prism::Node - def initialize(source, flags, elements, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::KeywordHashNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Array[Prism::Node]) } - def elements; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def symbol_keys?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -# Flags for keyword hash nodes. -module Prism::KeywordHashNodeFlags; end - -Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer) - -class Prism::KeywordRestParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::KeywordRestParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(Symbol)) } - def name; end - - sig { returns(T.nilable(Prism::Location)) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::LambdaNode < ::Prism::Node - def initialize(source, locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LambdaNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def parameters; end - - def type; end - - class << self - def type; end - end -end - -class Prism::LexCompat - def initialize(source, **options); end - - def options; end - def result; end - def source; end -end - -class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token - def ==(other); end -end - -module Prism::LexCompat::Heredoc - class << self - def build(opening); end - end -end - -class Prism::LexCompat::Heredoc::DashHeredoc - def initialize(split); end - - def <<(token); end - def split; end - def to_a; end - def tokens; end -end - -class Prism::LexCompat::Heredoc::DedentingHeredoc - def initialize; end - - def <<(token); end - def dedent; end - def dedent_next; end - def embexpr_balance; end - def to_a; end - def tokens; end -end - -Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer) - -class Prism::LexCompat::Heredoc::PlainHeredoc - def initialize; end - - def <<(token); end - def to_a; end - def tokens; end -end - -class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token - def ==(other); end -end - -class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token - def ==(other); end -end - -class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token - def ==(other); end -end - -class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token - def ==(other); end -end - -Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash) - -class Prism::LexCompat::Token < ::SimpleDelegator - def event; end - def location; end - def state; end - def value; end -end - -class Prism::LexRipper - def initialize(source); end - - def result; end - def source; end - - private - - def lex(source); end -end - -class Prism::LocalVariableAndWriteNode < ::Prism::Node - def initialize(source, name_loc, operator_loc, value, name, depth, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableAndWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::LocalVariableOperatorWriteNode < ::Prism::Node - def initialize(source, name_loc, operator_loc, value, name, operator, depth, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableOperatorWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(Symbol) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::LocalVariableOrWriteNode < ::Prism::Node - def initialize(source, name_loc, operator_loc, value, name, depth, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableOrWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def desugar; end - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::LocalVariableReadNode < ::Prism::Node - def initialize(source, name, depth, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::LocalVariableTargetNode < ::Prism::Node - def initialize(source, name, depth, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::LocalVariableWriteNode < ::Prism::Node - def initialize(source, name, depth, name_loc, value, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::LocalVariableWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Integer) } - def depth; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::Location - sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void } - def initialize(source, start_offset, length); end - - def ==(other); end - - sig { returns(T::Array[Prism::Comment]) } - def comments; end - - sig { params(options: T.untyped).returns(Prism::Location) } - def copy(**options); end - - def deconstruct_keys(keys); end - def end_character_column; end - def end_character_offset; end - def end_code_units_column(encoding = T.unsafe(nil)); end - def end_code_units_offset(encoding = T.unsafe(nil)); end - - sig { returns(Integer) } - def end_column; end - - sig { returns(Integer) } - def end_line; end - - sig { returns(Integer) } - def end_offset; end - - def inspect; end - def join(other); end - def length; end - def pretty_print(q); end - - sig { returns(String) } - def slice; end - - def start_character_column; end - def start_character_offset; end - def start_code_units_column(encoding = T.unsafe(nil)); end - def start_code_units_offset(encoding = T.unsafe(nil)); end - - sig { returns(Integer) } - def start_column; end - - sig { returns(Integer) } - def start_line; end - - def start_line_slice; end - - sig { returns(Integer) } - def start_offset; end - - protected - - def source; end - - class << self - def null; end - end -end - -# Flags for while and until loop nodes. -module Prism::LoopFlags; end - -Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer) - -class Prism::MagicComment - def initialize(key_loc, value_loc); end - - def deconstruct_keys(keys); end - def inspect; end - def key; end - def key_loc; end - def value; end - def value_loc; end -end - -class Prism::MatchLastLineNode < ::Prism::Node - include ::Prism::RegularExpressionOptions - - def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def ascii_8bit?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(String) } - def content; end - - sig { returns(Prism::Location) } - def content_loc; end - - sig { params(params: T.untyped).returns(Prism::MatchLastLineNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def euc_jp?; end - - sig { returns(T::Boolean) } - def extended?; end - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_us_ascii_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - sig { returns(T::Boolean) } - def ignore_case?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def multi_line?; end - - sig { returns(T::Boolean) } - def once?; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - def type; end - - sig { returns(String) } - def unescaped; end - - sig { returns(T::Boolean) } - def utf_8?; end - - sig { returns(T::Boolean) } - def windows_31j?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::MatchPredicateNode < ::Prism::Node - def initialize(source, value, pattern, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MatchPredicateNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def pattern; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::MatchRequiredNode < ::Prism::Node - def initialize(source, value, pattern, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MatchRequiredNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def pattern; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::MatchWriteNode < ::Prism::Node - def initialize(source, call, targets, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(Prism::CallNode) } - def call; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MatchWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Prism::Node]) } - def targets; end - - def type; end - - class << self - def type; end - end -end - -class Prism::MissingNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MissingNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::ModuleNode < ::Prism::Node - def initialize(source, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(Prism::Node) } - def constant_path; end - - sig { params(params: T.untyped).returns(Prism::ModuleNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(String) } - def module_keyword; end - - sig { returns(Prism::Location) } - def module_keyword_loc; end - - sig { returns(Symbol) } - def name; end - - def type; end - - class << self - def type; end - end -end - -class Prism::MultiTargetNode < ::Prism::Node - def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MultiTargetNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Prism::Node]) } - def lefts; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def rest; end - - sig { returns(T::Array[Prism::Node]) } - def rights; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::MultiWriteNode < ::Prism::Node - def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::MultiWriteNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Prism::Node]) } - def lefts; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def rest; end - - sig { returns(T::Array[Prism::Node]) } - def rights; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - class << self - def type; end - end -end - -class Prism::MutationCompiler < ::Prism::Compiler - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end -end - -class Prism::NextNode < ::Prism::Node - def initialize(source, arguments, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::NextNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::NilNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::NilNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::NoKeywordsParameterNode < ::Prism::Node - def initialize(source, operator_loc, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::NoKeywordsParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::Node - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - - sig { returns(T::Array[Prism::Node]) } - def compact_child_nodes; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - sig { returns(Prism::Location) } - def location; end - - def newline?; end - def pretty_print(q); end - def set_newline_flag(newline_marked); end - - sig { returns(String) } - def slice; end - - sig { returns(String) } - def to_dot; end - - sig { returns(Symbol) } - def type; end - - private - - def source; end -end - -class Prism::NodeInspector - def initialize(prefix = T.unsafe(nil)); end - - # Appends a line to the output with the current prefix. - sig { params(line: String).void } - def <<(line); end - - # Returns a new inspector that can be used to inspect a child node. - sig { params(append: String).returns(Prism::NodeInspector) } - def child_inspector(append); end - - # Generates a string that represents a child node. - 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. - 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. - 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. - sig { params(value: Prism::Location).returns(String) } - def location(value); end - - sig { returns(String) } - def output; end - - sig { returns(String) } - def prefix; end - - # Returns the output as a string. - sig { returns(String) } - def to_str; end -end - -class Prism::NumberedParametersNode < ::Prism::Node - def initialize(source, maximum, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::NumberedParametersNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Integer) } - def maximum; end - - def type; end - - class << self - def type; end - end -end - -class Prism::NumberedReferenceReadNode < ::Prism::Node - def initialize(source, number, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::NumberedReferenceReadNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Integer) } - def number; end - - def type; end - - class << self - def type; end - end -end - -class Prism::OptionalKeywordParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::OptionalKeywordParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::OptionalParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, operator_loc, value, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::OptionalParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - sig { returns(Prism::Node) } - def value; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::OrNode < ::Prism::Node - def initialize(source, left, right, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::OrNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def left; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(Prism::Node) } - def right; end - - def type; end - - class << self - def type; end - end -end - -module Prism::Pack - class << self - def parse(_arg0, _arg1, _arg2); end - end -end - -Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol) -Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol) -Prism::Pack::BER = T.let(T.unsafe(nil), Symbol) -Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol) -Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol) - -class Prism::Pack::Directive - def initialize(version, variant, source, type, signed, endian, size, length_type, length); end - - def describe; end - def endian; end - def length; end - def length_type; end - def signed; end - def size; end - def source; end - def type; end - def variant; end - def version; end -end - -Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) -Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) -Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) -Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol) -Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol) - -class Prism::Pack::Format - def initialize(directives, encoding); end - - def describe; end - def directives; end - def encoding; end -end - -Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol) -Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol) -Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol) -Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol) -Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol) -Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol) -Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol) -Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol) -Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol) -Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol) -Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol) - -# Flags for parameter nodes. -module Prism::ParameterFlags; end - -Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer) - -class Prism::ParametersNode < ::Prism::Node - def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::BlockParameterNode)) } - def block; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ParametersNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def keyword_rest; end - - sig { returns(T::Array[Prism::Node]) } - def keywords; end - - sig { returns(T::Array[Prism::Node]) } - def optionals; end - - sig { returns(T::Array[Prism::Node]) } - def posts; end - - sig { returns(T::Array[Prism::Node]) } - def requireds; end - - sig { returns(T.nilable(Prism::Node)) } - def rest; end - - def signature; end - def type; end - - class << self - def type; end - end -end - -class Prism::ParenthesesNode < ::Prism::Node - def initialize(source, body, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ParenthesesNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - def set_newline_flag(newline_marked); end - def type; end - - class << self - def type; end - end -end - -class Prism::ParseError - def initialize(message, location, level); end - - def deconstruct_keys(keys); end - def inspect; end - def level; end - - sig { returns(Prism::Location) } - def location; end - - sig { returns(String) } - def message; end -end - -class Prism::ParseResult - def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end - - def attach_comments!; end - - sig { returns(T::Array[Prism::Comment]) } - def comments; end - - def data_loc; end - def deconstruct_keys(keys); end - - sig { returns(T::Array[Prism::ParseError]) } - def errors; end - - def failure?; end - def magic_comments; end - def mark_newlines!; end - - sig { returns(Prism::Source) } - def source; end - - def success?; end - - sig { returns(Prism::ProgramNode) } - def value; end - - sig { returns(T::Array[Prism::ParseWarning]) } - def warnings; end -end - -class Prism::ParseResult::Comments - def initialize(parse_result); end - - def attach!; end - def parse_result; end - - private - - def nearest_targets(node, comment); end -end - -class Prism::ParseResult::Comments::LocationTarget - def initialize(location); end - - def <<(comment); end - def encloses?(comment); end - def end_offset; end - def location; end - def start_offset; end -end - -class Prism::ParseResult::Comments::NodeTarget - def initialize(node); end - - def <<(comment); end - def encloses?(comment); end - def end_offset; end - def node; end - def start_offset; end -end - -class Prism::ParseResult::Newlines < ::Prism::Visitor - def initialize(newline_marked); end - - def visit_block_node(node); end - def visit_if_node(node); end - def visit_lambda_node(node); end - def visit_statements_node(node); end - def visit_unless_node(node); end -end - -class Prism::ParseWarning - def initialize(message, location, level); end - - def deconstruct_keys(keys); end - def inspect; end - def level; end - - sig { returns(Prism::Location) } - def location; end - - sig { returns(String) } - def message; end -end - -class Prism::Pattern - def initialize(query); end - - def compile; end - def query; end - def scan(root); end - - private - - def combine_and(left, right); end - def combine_or(left, right); end - def compile_alternation_pattern_node(node); end - def compile_array_pattern_node(node); end - def compile_constant_path_node(node); end - def compile_constant_read_node(node); end - def compile_error(node); end - def compile_hash_pattern_node(node); end - def compile_nil_node(node); end - def compile_node(node); end - def compile_regular_expression_node(node); end - def compile_string_node(node); end - def compile_symbol_node(node); end -end - -class Prism::Pattern::CompilationError < ::StandardError - def initialize(repr); end -end - -class Prism::PinnedExpressionNode < ::Prism::Node - def initialize(source, expression, operator_loc, lparen_loc, rparen_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::PinnedExpressionNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Prism::Node) } - def expression; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def lparen; end - - sig { returns(Prism::Location) } - def lparen_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(String) } - def rparen; end - - sig { returns(Prism::Location) } - def rparen_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::PinnedVariableNode < ::Prism::Node - def initialize(source, variable, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::PinnedVariableNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - sig { returns(Prism::Node) } - def variable; end - - class << self - def type; end - end -end - -class Prism::PostExecutionNode < ::Prism::Node - def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::PostExecutionNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::PreExecutionNode < ::Prism::Node - def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::PreExecutionNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::ProgramNode < ::Prism::Node - def initialize(source, locals, statements, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ProgramNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(Prism::StatementsNode) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -# Flags for range and flip-flop nodes. -module Prism::RangeFlags; end - -Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) - -class Prism::RangeNode < ::Prism::Node - def initialize(source, flags, left, right, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RangeNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def exclude_end?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(Prism::Node)) } - def left; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def right; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::RationalNode < ::Prism::Node - def initialize(source, numeric, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RationalNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Prism::Node) } - def numeric; end - - def type; end - def value; end - - class << self - def type; end - end -end - -class Prism::RedoNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RedoNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -# Flags for regular expression and match last line nodes. -module Prism::RegularExpressionFlags; end - -Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer) -Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) - -class Prism::RegularExpressionNode < ::Prism::Node - include ::Prism::RegularExpressionOptions - - def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def ascii_8bit?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(String) } - def content; end - - sig { returns(Prism::Location) } - def content_loc; end - - sig { params(params: T.untyped).returns(Prism::RegularExpressionNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def euc_jp?; end - - sig { returns(T::Boolean) } - def extended?; end - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_us_ascii_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - sig { returns(T::Boolean) } - def ignore_case?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Boolean) } - def multi_line?; end - - sig { returns(T::Boolean) } - def once?; end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - def type; end - - sig { returns(String) } - def unescaped; end - - sig { returns(T::Boolean) } - def utf_8?; end - - sig { returns(T::Boolean) } - def windows_31j?; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -module Prism::RegularExpressionOptions - def options; end -end - -class Prism::RequiredKeywordParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RequiredKeywordParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(Prism::Location) } - def name_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::RequiredParameterNode < ::Prism::Node - def initialize(source, flags, name, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RequiredParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(Symbol) } - def name; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::RescueModifierNode < ::Prism::Node - def initialize(source, expression, keyword_loc, rescue_expression, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RescueModifierNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(Prism::Node) } - def expression; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def rescue_expression; end - - def set_newline_flag(newline_marked); end - def type; end - - class << self - def type; end - end -end - -class Prism::RescueNode < ::Prism::Node - def initialize(source, keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::RescueNode)) } - def consequent; end - - sig { params(params: T.untyped).returns(Prism::RescueNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Array[Prism::Node]) } - def exceptions; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T.nilable(String)) } - def operator; end - - sig { returns(T.nilable(Prism::Location)) } - def operator_loc; end - - sig { returns(T.nilable(Prism::Node)) } - def reference; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::RestParameterNode < ::Prism::Node - def initialize(source, flags, name, name_loc, operator_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RestParameterNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(T.nilable(Symbol)) } - def name; end - - sig { returns(T.nilable(Prism::Location)) } - def name_loc; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - sig { returns(T::Boolean) } - def repeated_parameter?; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::RetryNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::RetryNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::ReturnNode < ::Prism::Node - def initialize(source, keyword_loc, arguments, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::ReturnNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::SelfNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SelfNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -module Prism::Serialize - class << self - def load(input, serialized); end - def load_tokens(source, serialized); end - end -end - -class Prism::Serialize::Loader - def initialize(source, serialized); end - - def constant_pool; end - def constant_pool_offset; end - def encoding; end - def input; end - def io; end - def load_comments; end - def load_encoding; end - def load_header; end - def load_line_offsets; end - def load_metadata; end - def load_nodes; end - def load_result; end - def load_start_line; end - def load_tokens; end - def load_tokens_result; end - def serialized; end - def source; end - def start_line; end - - private - - def load_constant(index); end - def load_embedded_string; end - def load_error_level; end - def load_location; end - def load_node; end - def load_optional_constant; end - def load_optional_location; end - def load_optional_node; end - def load_required_constant; end - def load_serialized_length; end - def load_string; end - def load_varsint; end - def load_varuint; end - def load_warning_level; end -end - -Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer) -Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer) -Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer) -Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array) - -class Prism::SingletonClassNode < ::Prism::Node - def initialize(source, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::Node)) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def class_keyword; end - - sig { returns(Prism::Location) } - def class_keyword_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SingletonClassNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def end_keyword; end - - sig { returns(Prism::Location) } - def end_keyword_loc; end - - sig { returns(Prism::Node) } - def expression; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T::Array[Symbol]) } - def locals; end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::Source - def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end - - def character_column(byte_offset); end - def character_offset(byte_offset); end - def code_units_column(byte_offset, encoding); end - def code_units_offset(byte_offset, encoding); end - def column(byte_offset); end - def line(byte_offset); end - - sig { params(value: Integer).returns(Integer) } - def line_offset(value); end - - def line_start(byte_offset); end - - sig { returns(T::Array[Integer]) } - def offsets; end - - def slice(byte_offset, length); end - - sig { returns(String) } - def source; end - - def start_line; end - - private - - def find_line(byte_offset); end -end - -class Prism::SourceEncodingNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SourceEncodingNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::SourceFileNode < ::Prism::Node - def initialize(source, filepath, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SourceFileNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(String) } - def filepath; end - - def inspect(inspector = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::SourceLineNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SourceLineNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::SplatNode < ::Prism::Node - def initialize(source, operator_loc, expression, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SplatNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(Prism::Node)) } - def expression; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def operator; end - - sig { returns(Prism::Location) } - def operator_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::StatementsNode < ::Prism::Node - def initialize(source, body, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[Prism::Node]) } - def body; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::StatementsNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -# Flags for string nodes. -module Prism::StringFlags; end - -Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer) - -class Prism::StringNode < ::Prism::Node - include ::Prism::HeredocQuery - - def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(String) } - def content; end - - sig { returns(Prism::Location) } - def content_loc; end - - sig { params(params: T.untyped).returns(Prism::StringNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - sig { returns(T::Boolean) } - def frozen?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - def type; end - - sig { returns(String) } - def unescaped; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::SuperNode < ::Prism::Node - def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T.nilable(Prism::Node)) } - def block; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SuperNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - class << self - def type; end - end -end - -# Flags for symbol nodes. -module Prism::SymbolFlags; end - -Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) -Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) - -class Prism::SymbolNode < ::Prism::Node - def initialize(source, flags, opening_loc, value_loc, closing_loc, unescaped, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::SymbolNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_us_ascii_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(T.nilable(String)) } - def opening; end - - sig { returns(T.nilable(Prism::Location)) } - def opening_loc; end - - def type; end - - sig { returns(String) } - def unescaped; end - - sig { returns(T.nilable(String)) } - def value; end - - sig { returns(T.nilable(Prism::Location)) } - def value_loc; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::Token - def initialize(source, type, value, location); end - - sig { params(other: T.untyped).returns(T::Boolean) } - def ==(other); end - - sig { params(keys: T.untyped).returns(T.untyped) } - def deconstruct_keys(keys); end - - sig { returns(Prism::Location) } - def location; end - - sig { params(q: T.untyped).returns(T.untyped) } - def pretty_print(q); end - - sig { returns(T.untyped) } - def type; end - - sig { returns(String) } - def value; end - - private - - def source; end -end - -module Prism::Translation; end - -class Prism::Translation::Parser < ::Parser::Base - def default_encoding; end - def parse(source_buffer); end - def parse_with_comments(source_buffer); end - def tokenize(source_buffer, recover = T.unsafe(nil)); end - def try_declare_numparam(node); end - def version; end - def yyerror; end - - private - - def build_ast(program, offset_cache); end - def build_comments(comments, offset_cache); end - def build_offset_cache(source); end - def build_range(location, offset_cache); end - def build_tokens(tokens, offset_cache); end - def convert_for_prism(version); end - def unwrap(result, offset_cache); end - def valid_error?(error); end -end - -class Prism::Translation::Parser::Compiler < ::Prism::Compiler - def initialize(parser, offset_cache, forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end - - def builder; end - def forwarding; end - def in_destructure; end - def in_pattern; end - def offset_cache; end - def parser; end - def source_buffer; end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_alternation_pattern_node(node); end - def visit_and_node(node); end - def visit_arguments_node(node); end - def visit_array_node(node); end - def visit_array_pattern_node(node); end - def visit_assoc_node(node); end - def visit_assoc_splat_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_argument_node(node); end - def visit_block_local_variable_node(node); end - def visit_block_node(node); end - def visit_block_parameter_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_and_write_node(node); end - def visit_call_node(node); end - def visit_call_operator_write_node(node); end - def visit_call_or_write_node(node); end - def visit_call_target_node(node); end - def visit_capture_pattern_node(node); end - def visit_case_match_node(node); end - def visit_case_node(node); end - def visit_class_node(node); end - def visit_class_variable_and_write_node(node); end - def visit_class_variable_operator_write_node(node); end - def visit_class_variable_or_write_node(node); end - def visit_class_variable_read_node(node); end - def visit_class_variable_target_node(node); end - def visit_class_variable_write_node(node); end - def visit_constant_and_write_node(node); end - def visit_constant_operator_write_node(node); end - def visit_constant_or_write_node(node); end - def visit_constant_path_and_write_node(node); end - def visit_constant_path_node(node); end - def visit_constant_path_operator_write_node(node); end - def visit_constant_path_or_write_node(node); end - def visit_constant_path_target_node(node); end - def visit_constant_path_write_node(node); end - def visit_constant_read_node(node); end - def visit_constant_target_node(node); end - def visit_constant_write_node(node); end - def visit_def_node(node); end - def visit_defined_node(node); end - def visit_else_node(node); end - def visit_embedded_statements_node(node); end - def visit_embedded_variable_node(node); end - def visit_ensure_node(node); end - def visit_false_node(node); end - def visit_find_pattern_node(node); end - def visit_flip_flop_node(node); end - def visit_float_node(node); end - def visit_for_node(node); end - def visit_forwarding_arguments_node(node); end - def visit_forwarding_parameter_node(node); end - def visit_forwarding_super_node(node); end - def visit_global_variable_and_write_node(node); end - def visit_global_variable_operator_write_node(node); end - def visit_global_variable_or_write_node(node); end - def visit_global_variable_read_node(node); end - def visit_global_variable_target_node(node); end - def visit_global_variable_write_node(node); end - def visit_hash_node(node); end - def visit_hash_pattern_node(node); end - def visit_if_node(node); end - def visit_imaginary_node(node); end - def visit_implicit_node(node); end - def visit_implicit_rest_node(node); end - def visit_in_node(node); end - def visit_index_and_write_node(node); end - def visit_index_operator_write_node(node); end - def visit_index_or_write_node(node); end - def visit_index_target_node(node); end - def visit_instance_variable_and_write_node(node); end - def visit_instance_variable_operator_write_node(node); end - def visit_instance_variable_or_write_node(node); end - def visit_instance_variable_read_node(node); end - def visit_instance_variable_target_node(node); end - def visit_instance_variable_write_node(node); end - def visit_integer_node(node); end - def visit_interpolated_match_last_line_node(node); end - def visit_interpolated_regular_expression_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_interpolated_x_string_node(node); end - def visit_keyword_hash_node(node); end - def visit_keyword_rest_parameter_node(node); end - def visit_lambda_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_target_node(node); end - def visit_local_variable_write_node(node); end - def visit_match_last_line_node(node); end - def visit_match_predicate_node(node); end - def visit_match_required_node(node); end - def visit_match_write_node(node); end - def visit_missing_node(node); end - def visit_module_node(node); end - def visit_multi_target_node(node); end - def visit_multi_write_node(node); end - def visit_next_node(node); end - def visit_nil_node(node); end - def visit_no_keywords_parameter_node(node); end - def visit_numbered_parameters_node(node); end - def visit_numbered_reference_read_node(node); end - def visit_optional_keyword_parameter_node(node); end - def visit_optional_parameter_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_pinned_expression_node(node); end - def visit_pinned_variable_node(node); end - def visit_post_execution_node(node); end - def visit_pre_execution_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_redo_node(node); end - def visit_regular_expression_node(node); end - def visit_required_keyword_parameter_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_modifier_node(node); end - def visit_rescue_node(node); end - def visit_rest_parameter_node(node); end - def visit_retry_node(node); end - def visit_return_node(node); end - def visit_self_node(node); end - def visit_singleton_class_node(node); end - def visit_source_encoding_node(node); end - def visit_source_file_node(node); end - def visit_source_line_node(node); end - def visit_splat_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_super_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_undef_node(node); end - def visit_unless_node(node); end - def visit_until_node(node); end - def visit_when_node(node); end - def visit_while_node(node); end - def visit_x_string_node(node); end - def visit_yield_node(node); end - - private - - def copy_compiler(forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end - def find_forwarding(node); end - def procarg0?(parameters); end - def srange(location); end - def srange_find(start_offset, end_offset, tokens); end - def srange_offsets(start_offset, end_offset); end - def token(location); end - def visit_block(call, block); end - def visit_heredoc(node); end - def visit_numeric(node, value); end - def within_pattern; end -end - -class Prism::Translation::Parser::Compiler::CompilationError < ::StandardError; end -Prism::Translation::Parser::Compiler::Range = Parser::Source::Range - -class Prism::Translation::Parser::Diagnostic < ::Parser::Diagnostic - def initialize(message, location); end - - def message; end -end - -class Prism::Translation::Parser::Lexer - def initialize(source_buffer, lexed, offset_cache); end - - def lexed; end - def offset_cache; end - def source_buffer; end - def to_a; end - - private - - def parse_complex(value); end - def parse_rational(value); end -end - -Prism::Translation::Parser::Lexer::Range = Parser::Source::Range -Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash) -Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass) - -class Prism::Translation::Ripper < ::Prism::Compiler - def initialize(source); end - - def column; end - def error?; end - def lineno; end - def parse; end - def source; end - def visit_alias_global_variable_node(node); end - def visit_alias_method_node(node); end - def visit_and_node(node); end - def visit_array_node(node); end - def visit_back_reference_read_node(node); end - def visit_begin_node(node); end - def visit_block_node(node); end - def visit_block_parameters_node(node); end - def visit_break_node(node); end - def visit_call_node(node); end - def visit_embedded_statements_node(node); end - def visit_false_node(node); end - def visit_float_node(node); end - def visit_global_variable_read_node(node); end - def visit_imaginary_node(node); end - def visit_integer_node(node); end - def visit_interpolated_string_node(node); end - def visit_interpolated_symbol_node(node); end - def visit_local_variable_and_write_node(node); end - def visit_local_variable_operator_write_node(node); end - def visit_local_variable_or_write_node(node); end - def visit_local_variable_read_node(node); end - def visit_local_variable_write_node(node); end - def visit_or_node(node); end - def visit_parameters_node(node); end - def visit_parentheses_node(node); end - def visit_program_node(node); end - def visit_range_node(node); end - def visit_rational_node(node); end - def visit_required_parameter_node(node); end - def visit_rescue_node(node); end - def visit_statements_node(node); end - def visit_string_node(node); end - def visit_symbol_node(node); end - def visit_true_node(node); end - def visit_x_string_node(node); end - - private - - def _dispatch0; end - def _dispatch1(_); end - def _dispatch2(_, _); end - def _dispatch3(_, _, _); end - def _dispatch4(_, _, _, _); end - def _dispatch5(_, _, _, _, _); end - def _dispatch7(_, _, _, _, _, _, _); end - def bounds(location); end - def bounds_values(lineno, column); end - def no_block_value; end - def on_BEGIN(_); end - def on_CHAR(_); end - def on_END(_); end - def on___end__(_); end - def on_alias(_, _); end - def on_alias_error(_, _); end - def on_aref(_, _); end - def on_aref_field(_, _); end - def on_arg_ambiguous(_); end - def on_arg_paren(_); end - def on_args_add(_, _); end - def on_args_add_block(_, _); end - def on_args_add_star(_, _); end - def on_args_forward; end - def on_args_new; end - def on_array(_); end - def on_aryptn(_, _, _, _); end - def on_assign(_, _); end - def on_assign_error(_, _); end - def on_assoc_new(_, _); end - def on_assoc_splat(_); end - def on_assoclist_from_args(_); end - def on_backref(_); end - def on_backtick(_); end - def on_bare_assoc_hash(_); end - def on_begin(_); end - def on_binary(_, _, _); end - def on_block_var(_, _); end - def on_blockarg(_); end - def on_bodystmt(_, _, _, _); end - def on_brace_block(_, _); end - def on_break(_); end - def on_call(_, _, _); end - def on_case(_, _); end - def on_class(_, _, _); end - def on_class_name_error(_, _); end - def on_comma(_); end - def on_command(_, _); end - def on_command_call(_, _, _, _); end - def on_comment(_); end - def on_const(_); end - def on_const_path_field(_, _); end - def on_const_path_ref(_, _); end - def on_const_ref(_); end - def on_cvar(_); end - def on_def(_, _, _); end - def on_defined(_); end - def on_defs(_, _, _, _, _); end - def on_do_block(_, _); end - def on_dot2(_, _); end - def on_dot3(_, _); end - def on_dyna_symbol(_); end - def on_else(_); end - def on_elsif(_, _, _); end - def on_embdoc(_); end - def on_embdoc_beg(_); end - def on_embdoc_end(_); end - def on_embexpr_beg(_); end - def on_embexpr_end(_); end - def on_embvar(_); end - def on_ensure(_); end - def on_excessed_comma; end - def on_fcall(_); end - def on_field(_, _, _); end - def on_float(_); end - def on_fndptn(_, _, _, _); end - def on_for(_, _, _); end - def on_gvar(_); end - def on_hash(_); end - def on_heredoc_beg(_); end - def on_heredoc_dedent(_, _); end - def on_heredoc_end(_); end - def on_hshptn(_, _, _); end - def on_ident(_); end - def on_if(_, _, _); end - def on_if_mod(_, _); end - def on_ifop(_, _, _); end - def on_ignored_nl(_); end - def on_ignored_sp(_); end - def on_imaginary(_); end - def on_in(_, _, _); end - def on_int(_); end - def on_ivar(_); end - def on_kw(_); end - def on_kwrest_param(_); end - def on_label(_); end - def on_label_end(_); end - def on_lambda(_, _); end - def on_lbrace(_); end - def on_lbracket(_); end - def on_lparen(_); end - def on_magic_comment(_, _); end - def on_massign(_, _); end - def on_method_add_arg(_, _); end - def on_method_add_block(_, _); end - def on_mlhs_add(_, _); end - def on_mlhs_add_post(_, _); end - def on_mlhs_add_star(_, _); end - def on_mlhs_new; end - def on_mlhs_paren(_); end - def on_module(_, _); end - def on_mrhs_add(_, _); end - def on_mrhs_add_star(_, _); end - def on_mrhs_new; end - def on_mrhs_new_from_args(_); end - def on_next(_); end - def on_nl(_); end - def on_nokw_param(_); end - def on_op(_); end - def on_opassign(_, _, _); end - def on_operator_ambiguous(_, _); end - def on_param_error(_, _); end - def on_params(_, _, _, _, _, _, _); end - def on_paren(_); end - def on_parse_error(_); end - def on_period(_); end - def on_program(_); end - def on_qsymbols_add(_, _); end - def on_qsymbols_beg(_); end - def on_qsymbols_new; end - def on_qwords_add(_, _); end - def on_qwords_beg(_); end - def on_qwords_new; end - def on_rational(_); end - def on_rbrace(_); end - def on_rbracket(_); end - def on_redo; end - def on_regexp_add(_, _); end - def on_regexp_beg(_); end - def on_regexp_end(_); end - def on_regexp_literal(_, _); end - def on_regexp_new; end - def on_rescue(_, _, _, _); end - def on_rescue_mod(_, _); end - def on_rest_param(_); end - def on_retry; end - def on_return(_); end - def on_return0; end - def on_rparen(_); end - def on_sclass(_, _); end - def on_semicolon(_); end - def on_sp(_); end - def on_stmts_add(_, _); end - def on_stmts_new; end - def on_string_add(_, _); end - def on_string_concat(_, _); end - def on_string_content; end - def on_string_dvar(_); end - def on_string_embexpr(_); end - def on_string_literal(_); end - def on_super(_); end - def on_symbeg(_); end - def on_symbol(_); end - def on_symbol_literal(_); end - def on_symbols_add(_, _); end - def on_symbols_beg(_); end - def on_symbols_new; end - def on_tlambda(_); end - def on_tlambeg(_); end - def on_top_const_field(_); end - def on_top_const_ref(_); end - def on_tstring_beg(_); end - def on_tstring_content(_); end - def on_tstring_end(_); end - def on_unary(_, _); end - def on_undef(_); end - def on_unless(_, _, _); end - def on_unless_mod(_, _); end - def on_until(_, _); end - def on_until_mod(_, _); end - def on_var_alias(_, _); end - def on_var_field(_); end - def on_var_ref(_); end - def on_vcall(_); end - def on_void_stmt; end - def on_when(_, _, _); end - def on_while(_, _); end - def on_while_mod(_, _); end - def on_word_add(_, _); end - def on_word_new; end - def on_words_add(_, _); end - def on_words_beg(_); end - def on_words_new; end - def on_words_sep(_); end - def on_xstring_add(_, _); end - def on_xstring_literal(_); end - def on_xstring_new; end - def on_yield(_); end - def on_yield0; end - def on_zsuper; end - def result; end - def visit_aref_field_node(node); end - def visit_aref_node(node); end - def visit_binary_op_assign(node, operator: T.unsafe(nil)); end - def visit_binary_operator(node); end - def visit_elements(elements); end - def visit_enumerated_node(node); end - def visit_no_paren_call(node); end - def visit_number(node); end - def visit_symbol_literal_node(node, no_symbol_wrapper: T.unsafe(nil)); end - def visit_unary_operator(value); end - - class << self - def sexp(source); end - def sexp_raw(source); end - end -end - -Prism::Translation::Ripper::RUBY_KEYWORDS = T.let(T.unsafe(nil), Array) - -class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper - private - - def on_BEGIN(*args); end - def on_CHAR(value); end - def on_END(*args); end - def on___end__(value); end - def on_alias(*args); end - def on_alias_error(*args); end - def on_aref(*args); end - def on_aref_field(*args); end - def on_arg_ambiguous(*args); end - def on_arg_paren(*args); end - def on_args_add(*args); end - def on_args_add_block(*args); end - def on_args_add_star(*args); end - def on_args_forward(*args); end - def on_args_new(*args); end - def on_array(*args); end - def on_aryptn(*args); end - def on_assign(*args); end - def on_assign_error(*args); end - def on_assoc_new(*args); end - def on_assoc_splat(*args); end - def on_assoclist_from_args(*args); end - def on_backref(value); end - def on_backtick(value); end - def on_bare_assoc_hash(*args); end - def on_begin(*args); end - def on_binary(*args); end - def on_block_var(*args); end - def on_blockarg(*args); end - def on_bodystmt(*args); end - def on_brace_block(*args); end - def on_break(*args); end - def on_call(*args); end - def on_case(*args); end - def on_class(*args); end - def on_class_name_error(*args); end - def on_comma(value); end - def on_command(*args); end - def on_command_call(*args); end - def on_comment(value); end - def on_const(value); end - def on_const_path_field(*args); end - def on_const_path_ref(*args); end - def on_const_ref(*args); end - def on_cvar(value); end - def on_def(*args); end - def on_defined(*args); end - def on_defs(*args); end - def on_do_block(*args); end - def on_dot2(*args); end - def on_dot3(*args); end - def on_dyna_symbol(*args); end - def on_else(*args); end - def on_elsif(*args); end - def on_embdoc(value); end - def on_embdoc_beg(value); end - def on_embdoc_end(value); end - def on_embexpr_beg(value); end - def on_embexpr_end(value); end - def on_embvar(value); end - def on_ensure(*args); end - def on_excessed_comma(*args); end - def on_fcall(*args); end - def on_field(*args); end - def on_float(value); end - def on_fndptn(*args); end - def on_for(*args); end - def on_gvar(value); end - def on_hash(*args); end - def on_heredoc_beg(value); end - def on_heredoc_dedent(*args); end - def on_heredoc_end(value); end - def on_hshptn(*args); end - def on_ident(value); end - def on_if(*args); end - def on_if_mod(*args); end - def on_ifop(*args); end - def on_ignored_nl(value); end - def on_ignored_sp(value); end - def on_imaginary(value); end - def on_in(*args); end - def on_int(value); end - def on_ivar(value); end - def on_kw(value); end - def on_kwrest_param(*args); end - def on_label(value); end - def on_label_end(value); end - def on_lambda(*args); end - def on_lbrace(value); end - def on_lbracket(value); end - def on_lparen(value); end - def on_magic_comment(*args); end - def on_massign(*args); end - def on_method_add_arg(*args); end - def on_method_add_block(*args); end - def on_mlhs_add(*args); end - def on_mlhs_add_post(*args); end - def on_mlhs_add_star(*args); end - def on_mlhs_new(*args); end - def on_mlhs_paren(*args); end - def on_module(*args); end - def on_mrhs_add(*args); end - def on_mrhs_add_star(*args); end - def on_mrhs_new(*args); end - def on_mrhs_new_from_args(*args); end - def on_next(*args); end - def on_nl(value); end - def on_nokw_param(*args); end - def on_op(value); end - def on_opassign(*args); end - def on_operator_ambiguous(*args); end - def on_param_error(*args); end - def on_params(*args); end - def on_paren(*args); end - def on_parse_error(*args); end - def on_period(value); end - def on_program(*args); end - def on_qsymbols_add(*args); end - def on_qsymbols_beg(value); end - def on_qsymbols_new(*args); end - def on_qwords_add(*args); end - def on_qwords_beg(value); end - def on_qwords_new(*args); end - def on_rational(value); end - def on_rbrace(value); end - def on_rbracket(value); end - def on_redo(*args); end - def on_regexp_add(*args); end - def on_regexp_beg(value); end - def on_regexp_end(value); end - def on_regexp_literal(*args); end - def on_regexp_new(*args); end - def on_rescue(*args); end - def on_rescue_mod(*args); end - def on_rest_param(*args); end - def on_retry(*args); end - def on_return(*args); end - def on_return0(*args); end - def on_rparen(value); end - def on_sclass(*args); end - def on_semicolon(value); end - def on_sp(value); end - def on_stmts_add(*args); end - def on_stmts_new(*args); end - def on_string_add(*args); end - def on_string_concat(*args); end - def on_string_content(*args); end - def on_string_dvar(*args); end - def on_string_embexpr(*args); end - def on_string_literal(*args); end - def on_super(*args); end - def on_symbeg(value); end - def on_symbol(*args); end - def on_symbol_literal(*args); end - def on_symbols_add(*args); end - def on_symbols_beg(value); end - def on_symbols_new(*args); end - def on_tlambda(value); end - def on_tlambeg(value); end - def on_top_const_field(*args); end - def on_top_const_ref(*args); end - def on_tstring_beg(value); end - def on_tstring_content(value); end - def on_tstring_end(value); end - def on_unary(*args); end - def on_undef(*args); end - def on_unless(*args); end - def on_unless_mod(*args); end - def on_until(*args); end - def on_until_mod(*args); end - def on_var_alias(*args); end - def on_var_field(*args); end - def on_var_ref(*args); end - def on_vcall(*args); end - def on_void_stmt(*args); end - def on_when(*args); end - def on_while(*args); end - def on_while_mod(*args); end - def on_word_add(*args); end - def on_word_new(*args); end - def on_words_add(*args); end - def on_words_beg(value); end - def on_words_new(*args); end - def on_words_sep(value); end - def on_xstring_add(*args); end - def on_xstring_literal(*args); end - def on_xstring_new(*args); end - def on_yield(*args); end - def on_yield0(*args); end - def on_zsuper(*args); end -end - -class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder - private - - def _dispatch_event_new; end - def _dispatch_event_push(list, item); end - def on_args_add(list, item); end - def on_args_new; end - def on_mlhs_add(list, item); end - def on_mlhs_new; end - def on_mrhs_add(list, item); end - def on_mrhs_new; end - def on_qsymbols_add(list, item); end - def on_qsymbols_new; end - def on_qwords_add(list, item); end - def on_qwords_new; end - def on_regexp_add(list, item); end - def on_regexp_new; end - def on_stmts_add(list, item); end - def on_stmts_new; end - def on_string_add(list, item); end - def on_symbols_add(list, item); end - def on_symbols_new; end - def on_word_add(list, item); end - def on_word_new; end - def on_words_add(list, item); end - def on_words_new; end - def on_xstring_add(list, item); end - def on_xstring_new; end -end - -class Prism::TrueNode < ::Prism::Node - def initialize(source, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::TrueNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - def type; end - - class << self - def type; end - end -end - -class Prism::UndefNode < ::Prism::Node - def initialize(source, names, keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::UndefNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T::Array[Prism::Node]) } - def names; end - - def type; end - - class << self - def type; end - end -end - -class Prism::UnlessNode < ::Prism::Node - def initialize(source, keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T.nilable(Prism::ElseNode)) } - def consequent; end - - sig { params(params: T.untyped).returns(Prism::UnlessNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T.nilable(String)) } - def end_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def end_keyword_loc; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def predicate; end - - def set_newline_flag(newline_marked); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - sig { returns(T.nilable(String)) } - def then_keyword; end - - sig { returns(T.nilable(Prism::Location)) } - def then_keyword_loc; end - - def type; end - - class << self - def type; end - end -end - -class Prism::UntilNode < ::Prism::Node - def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def begin_modifier?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::UntilNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def predicate; end - - def set_newline_flag(newline_marked); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -Prism::VERSION = T.let(T.unsafe(nil), String) - -class Prism::Visitor < ::Prism::BasicVisitor - # Visit a AliasGlobalVariableNode node - sig { params(node: Prism::AliasGlobalVariableNode).void } - def visit_alias_global_variable_node(node); end - - # Visit a AliasMethodNode node - sig { params(node: Prism::AliasMethodNode).void } - def visit_alias_method_node(node); end - - # Visit a AlternationPatternNode node - sig { params(node: Prism::AlternationPatternNode).void } - def visit_alternation_pattern_node(node); end - - # Visit a AndNode node - sig { params(node: Prism::AndNode).void } - def visit_and_node(node); end - - # Visit a ArgumentsNode node - sig { params(node: Prism::ArgumentsNode).void } - def visit_arguments_node(node); end - - # Visit a ArrayNode node - sig { params(node: Prism::ArrayNode).void } - def visit_array_node(node); end - - # Visit a ArrayPatternNode node - sig { params(node: Prism::ArrayPatternNode).void } - def visit_array_pattern_node(node); end - - # Visit a AssocNode node - sig { params(node: Prism::AssocNode).void } - def visit_assoc_node(node); end - - # Visit a AssocSplatNode node - sig { params(node: Prism::AssocSplatNode).void } - def visit_assoc_splat_node(node); end - - # Visit a BackReferenceReadNode node - sig { params(node: Prism::BackReferenceReadNode).void } - def visit_back_reference_read_node(node); end - - # Visit a BeginNode node - sig { params(node: Prism::BeginNode).void } - def visit_begin_node(node); end - - # Visit a BlockArgumentNode node - sig { params(node: Prism::BlockArgumentNode).void } - def visit_block_argument_node(node); end - - # Visit a BlockLocalVariableNode node - sig { params(node: Prism::BlockLocalVariableNode).void } - def visit_block_local_variable_node(node); end - - # Visit a BlockNode node - sig { params(node: Prism::BlockNode).void } - def visit_block_node(node); end - - # Visit a BlockParameterNode node - sig { params(node: Prism::BlockParameterNode).void } - def visit_block_parameter_node(node); end - - # Visit a BlockParametersNode node - sig { params(node: Prism::BlockParametersNode).void } - def visit_block_parameters_node(node); end - - # Visit a BreakNode node - sig { params(node: Prism::BreakNode).void } - def visit_break_node(node); end - - # Visit a CallAndWriteNode node - sig { params(node: Prism::CallAndWriteNode).void } - def visit_call_and_write_node(node); end - - # Visit a CallNode node - sig { params(node: Prism::CallNode).void } - def visit_call_node(node); end - - # Visit a CallOperatorWriteNode node - sig { params(node: Prism::CallOperatorWriteNode).void } - def visit_call_operator_write_node(node); end - - # Visit a CallOrWriteNode node - sig { params(node: Prism::CallOrWriteNode).void } - def visit_call_or_write_node(node); end - - # Visit a CallTargetNode node - sig { params(node: Prism::CallTargetNode).void } - def visit_call_target_node(node); end - - # Visit a CapturePatternNode node - sig { params(node: Prism::CapturePatternNode).void } - def visit_capture_pattern_node(node); end - - # Visit a CaseMatchNode node - sig { params(node: Prism::CaseMatchNode).void } - def visit_case_match_node(node); end - - # Visit a CaseNode node - sig { params(node: Prism::CaseNode).void } - def visit_case_node(node); end - - # Visit a ClassNode node - sig { params(node: Prism::ClassNode).void } - def visit_class_node(node); end - - # Visit a ClassVariableAndWriteNode node - sig { params(node: Prism::ClassVariableAndWriteNode).void } - def visit_class_variable_and_write_node(node); end - - # Visit a ClassVariableOperatorWriteNode node - sig { params(node: Prism::ClassVariableOperatorWriteNode).void } - def visit_class_variable_operator_write_node(node); end - - # Visit a ClassVariableOrWriteNode node - sig { params(node: Prism::ClassVariableOrWriteNode).void } - def visit_class_variable_or_write_node(node); end - - # Visit a ClassVariableReadNode node - sig { params(node: Prism::ClassVariableReadNode).void } - def visit_class_variable_read_node(node); end - - # Visit a ClassVariableTargetNode node - sig { params(node: Prism::ClassVariableTargetNode).void } - def visit_class_variable_target_node(node); end - - # Visit a ClassVariableWriteNode node - sig { params(node: Prism::ClassVariableWriteNode).void } - def visit_class_variable_write_node(node); end - - # Visit a ConstantAndWriteNode node - sig { params(node: Prism::ConstantAndWriteNode).void } - def visit_constant_and_write_node(node); end - - # Visit a ConstantOperatorWriteNode node - sig { params(node: Prism::ConstantOperatorWriteNode).void } - def visit_constant_operator_write_node(node); end - - # Visit a ConstantOrWriteNode node - sig { params(node: Prism::ConstantOrWriteNode).void } - def visit_constant_or_write_node(node); end - - # Visit a ConstantPathAndWriteNode node - sig { params(node: Prism::ConstantPathAndWriteNode).void } - def visit_constant_path_and_write_node(node); end - - # Visit a ConstantPathNode node - sig { params(node: Prism::ConstantPathNode).void } - def visit_constant_path_node(node); end - - # Visit a ConstantPathOperatorWriteNode node - sig { params(node: Prism::ConstantPathOperatorWriteNode).void } - def visit_constant_path_operator_write_node(node); end - - # Visit a ConstantPathOrWriteNode node - sig { params(node: Prism::ConstantPathOrWriteNode).void } - def visit_constant_path_or_write_node(node); end - - # Visit a ConstantPathTargetNode node - sig { params(node: Prism::ConstantPathTargetNode).void } - def visit_constant_path_target_node(node); end - - # Visit a ConstantPathWriteNode node - sig { params(node: Prism::ConstantPathWriteNode).void } - def visit_constant_path_write_node(node); end - - # Visit a ConstantReadNode node - sig { params(node: Prism::ConstantReadNode).void } - def visit_constant_read_node(node); end - - # Visit a ConstantTargetNode node - sig { params(node: Prism::ConstantTargetNode).void } - def visit_constant_target_node(node); end - - # Visit a ConstantWriteNode node - sig { params(node: Prism::ConstantWriteNode).void } - def visit_constant_write_node(node); end - - # Visit a DefNode node - sig { params(node: Prism::DefNode).void } - def visit_def_node(node); end - - # Visit a DefinedNode node - sig { params(node: Prism::DefinedNode).void } - def visit_defined_node(node); end - - # Visit a ElseNode node - sig { params(node: Prism::ElseNode).void } - def visit_else_node(node); end - - # Visit a EmbeddedStatementsNode node - sig { params(node: Prism::EmbeddedStatementsNode).void } - def visit_embedded_statements_node(node); end - - # Visit a EmbeddedVariableNode node - sig { params(node: Prism::EmbeddedVariableNode).void } - def visit_embedded_variable_node(node); end - - # Visit a EnsureNode node - sig { params(node: Prism::EnsureNode).void } - def visit_ensure_node(node); end - - # Visit a FalseNode node - sig { params(node: Prism::FalseNode).void } - def visit_false_node(node); end - - # Visit a FindPatternNode node - sig { params(node: Prism::FindPatternNode).void } - def visit_find_pattern_node(node); end - - # Visit a FlipFlopNode node - sig { params(node: Prism::FlipFlopNode).void } - def visit_flip_flop_node(node); end - - # Visit a FloatNode node - sig { params(node: Prism::FloatNode).void } - def visit_float_node(node); end - - # Visit a ForNode node - sig { params(node: Prism::ForNode).void } - def visit_for_node(node); end - - # Visit a ForwardingArgumentsNode node - sig { params(node: Prism::ForwardingArgumentsNode).void } - def visit_forwarding_arguments_node(node); end - - # Visit a ForwardingParameterNode node - sig { params(node: Prism::ForwardingParameterNode).void } - def visit_forwarding_parameter_node(node); end - - # Visit a ForwardingSuperNode node - sig { params(node: Prism::ForwardingSuperNode).void } - def visit_forwarding_super_node(node); end - - # Visit a GlobalVariableAndWriteNode node - sig { params(node: Prism::GlobalVariableAndWriteNode).void } - def visit_global_variable_and_write_node(node); end - - # Visit a GlobalVariableOperatorWriteNode node - sig { params(node: Prism::GlobalVariableOperatorWriteNode).void } - def visit_global_variable_operator_write_node(node); end - - # Visit a GlobalVariableOrWriteNode node - sig { params(node: Prism::GlobalVariableOrWriteNode).void } - def visit_global_variable_or_write_node(node); end - - # Visit a GlobalVariableReadNode node - sig { params(node: Prism::GlobalVariableReadNode).void } - def visit_global_variable_read_node(node); end - - # Visit a GlobalVariableTargetNode node - sig { params(node: Prism::GlobalVariableTargetNode).void } - def visit_global_variable_target_node(node); end - - # Visit a GlobalVariableWriteNode node - sig { params(node: Prism::GlobalVariableWriteNode).void } - def visit_global_variable_write_node(node); end - - # Visit a HashNode node - sig { params(node: Prism::HashNode).void } - def visit_hash_node(node); end - - # Visit a HashPatternNode node - sig { params(node: Prism::HashPatternNode).void } - def visit_hash_pattern_node(node); end - - # Visit a IfNode node - sig { params(node: Prism::IfNode).void } - def visit_if_node(node); end - - # Visit a ImaginaryNode node - sig { params(node: Prism::ImaginaryNode).void } - def visit_imaginary_node(node); end - - # Visit a ImplicitNode node - sig { params(node: Prism::ImplicitNode).void } - def visit_implicit_node(node); end - - # Visit a ImplicitRestNode node - sig { params(node: Prism::ImplicitRestNode).void } - def visit_implicit_rest_node(node); end - - # Visit a InNode node - sig { params(node: Prism::InNode).void } - def visit_in_node(node); end - - # Visit a IndexAndWriteNode node - sig { params(node: Prism::IndexAndWriteNode).void } - def visit_index_and_write_node(node); end - - # Visit a IndexOperatorWriteNode node - sig { params(node: Prism::IndexOperatorWriteNode).void } - def visit_index_operator_write_node(node); end - - # Visit a IndexOrWriteNode node - sig { params(node: Prism::IndexOrWriteNode).void } - def visit_index_or_write_node(node); end - - # Visit a IndexTargetNode node - sig { params(node: Prism::IndexTargetNode).void } - def visit_index_target_node(node); end - - # Visit a InstanceVariableAndWriteNode node - sig { params(node: Prism::InstanceVariableAndWriteNode).void } - def visit_instance_variable_and_write_node(node); end - - # Visit a InstanceVariableOperatorWriteNode node - sig { params(node: Prism::InstanceVariableOperatorWriteNode).void } - def visit_instance_variable_operator_write_node(node); end - - # Visit a InstanceVariableOrWriteNode node - sig { params(node: Prism::InstanceVariableOrWriteNode).void } - def visit_instance_variable_or_write_node(node); end - - # Visit a InstanceVariableReadNode node - sig { params(node: Prism::InstanceVariableReadNode).void } - def visit_instance_variable_read_node(node); end - - # Visit a InstanceVariableTargetNode node - sig { params(node: Prism::InstanceVariableTargetNode).void } - def visit_instance_variable_target_node(node); end - - # Visit a InstanceVariableWriteNode node - sig { params(node: Prism::InstanceVariableWriteNode).void } - def visit_instance_variable_write_node(node); end - - # Visit a IntegerNode node - sig { params(node: Prism::IntegerNode).void } - def visit_integer_node(node); end - - # Visit a InterpolatedMatchLastLineNode node - sig { params(node: Prism::InterpolatedMatchLastLineNode).void } - def visit_interpolated_match_last_line_node(node); end - - # Visit a InterpolatedRegularExpressionNode node - sig { params(node: Prism::InterpolatedRegularExpressionNode).void } - def visit_interpolated_regular_expression_node(node); end - - # Visit a InterpolatedStringNode node - sig { params(node: Prism::InterpolatedStringNode).void } - def visit_interpolated_string_node(node); end - - # Visit a InterpolatedSymbolNode node - sig { params(node: Prism::InterpolatedSymbolNode).void } - def visit_interpolated_symbol_node(node); end - - # Visit a InterpolatedXStringNode node - sig { params(node: Prism::InterpolatedXStringNode).void } - def visit_interpolated_x_string_node(node); end - - # Visit a KeywordHashNode node - sig { params(node: Prism::KeywordHashNode).void } - def visit_keyword_hash_node(node); end - - # Visit a KeywordRestParameterNode node - sig { params(node: Prism::KeywordRestParameterNode).void } - def visit_keyword_rest_parameter_node(node); end - - # Visit a LambdaNode node - sig { params(node: Prism::LambdaNode).void } - def visit_lambda_node(node); end - - # Visit a LocalVariableAndWriteNode node - sig { params(node: Prism::LocalVariableAndWriteNode).void } - def visit_local_variable_and_write_node(node); end - - # Visit a LocalVariableOperatorWriteNode node - sig { params(node: Prism::LocalVariableOperatorWriteNode).void } - def visit_local_variable_operator_write_node(node); end - - # Visit a LocalVariableOrWriteNode node - sig { params(node: Prism::LocalVariableOrWriteNode).void } - def visit_local_variable_or_write_node(node); end - - # Visit a LocalVariableReadNode node - sig { params(node: Prism::LocalVariableReadNode).void } - def visit_local_variable_read_node(node); end - - # Visit a LocalVariableTargetNode node - sig { params(node: Prism::LocalVariableTargetNode).void } - def visit_local_variable_target_node(node); end - - # Visit a LocalVariableWriteNode node - sig { params(node: Prism::LocalVariableWriteNode).void } - def visit_local_variable_write_node(node); end - - # Visit a MatchLastLineNode node - sig { params(node: Prism::MatchLastLineNode).void } - def visit_match_last_line_node(node); end - - # Visit a MatchPredicateNode node - sig { params(node: Prism::MatchPredicateNode).void } - def visit_match_predicate_node(node); end - - # Visit a MatchRequiredNode node - sig { params(node: Prism::MatchRequiredNode).void } - def visit_match_required_node(node); end - - # Visit a MatchWriteNode node - sig { params(node: Prism::MatchWriteNode).void } - def visit_match_write_node(node); end - - # Visit a MissingNode node - sig { params(node: Prism::MissingNode).void } - def visit_missing_node(node); end - - # Visit a ModuleNode node - sig { params(node: Prism::ModuleNode).void } - def visit_module_node(node); end - - # Visit a MultiTargetNode node - sig { params(node: Prism::MultiTargetNode).void } - def visit_multi_target_node(node); end - - # Visit a MultiWriteNode node - sig { params(node: Prism::MultiWriteNode).void } - def visit_multi_write_node(node); end - - # Visit a NextNode node - sig { params(node: Prism::NextNode).void } - def visit_next_node(node); end - - # Visit a NilNode node - sig { params(node: Prism::NilNode).void } - def visit_nil_node(node); end - - # Visit a NoKeywordsParameterNode node - sig { params(node: Prism::NoKeywordsParameterNode).void } - def visit_no_keywords_parameter_node(node); end - - # Visit a NumberedParametersNode node - sig { params(node: Prism::NumberedParametersNode).void } - def visit_numbered_parameters_node(node); end - - # Visit a NumberedReferenceReadNode node - sig { params(node: Prism::NumberedReferenceReadNode).void } - def visit_numbered_reference_read_node(node); end - - # Visit a OptionalKeywordParameterNode node - sig { params(node: Prism::OptionalKeywordParameterNode).void } - def visit_optional_keyword_parameter_node(node); end - - # Visit a OptionalParameterNode node - sig { params(node: Prism::OptionalParameterNode).void } - def visit_optional_parameter_node(node); end - - # Visit a OrNode node - sig { params(node: Prism::OrNode).void } - def visit_or_node(node); end - - # Visit a ParametersNode node - sig { params(node: Prism::ParametersNode).void } - def visit_parameters_node(node); end - - # Visit a ParenthesesNode node - sig { params(node: Prism::ParenthesesNode).void } - def visit_parentheses_node(node); end - - # Visit a PinnedExpressionNode node - sig { params(node: Prism::PinnedExpressionNode).void } - def visit_pinned_expression_node(node); end - - # Visit a PinnedVariableNode node - sig { params(node: Prism::PinnedVariableNode).void } - def visit_pinned_variable_node(node); end - - # Visit a PostExecutionNode node - sig { params(node: Prism::PostExecutionNode).void } - def visit_post_execution_node(node); end - - # Visit a PreExecutionNode node - sig { params(node: Prism::PreExecutionNode).void } - def visit_pre_execution_node(node); end - - # Visit a ProgramNode node - sig { params(node: Prism::ProgramNode).void } - def visit_program_node(node); end - - # Visit a RangeNode node - sig { params(node: Prism::RangeNode).void } - def visit_range_node(node); end - - # Visit a RationalNode node - sig { params(node: Prism::RationalNode).void } - def visit_rational_node(node); end - - # Visit a RedoNode node - sig { params(node: Prism::RedoNode).void } - def visit_redo_node(node); end - - # Visit a RegularExpressionNode node - sig { params(node: Prism::RegularExpressionNode).void } - def visit_regular_expression_node(node); end - - # Visit a RequiredKeywordParameterNode node - sig { params(node: Prism::RequiredKeywordParameterNode).void } - def visit_required_keyword_parameter_node(node); end - - # Visit a RequiredParameterNode node - sig { params(node: Prism::RequiredParameterNode).void } - def visit_required_parameter_node(node); end - - # Visit a RescueModifierNode node - sig { params(node: Prism::RescueModifierNode).void } - def visit_rescue_modifier_node(node); end - - # Visit a RescueNode node - sig { params(node: Prism::RescueNode).void } - def visit_rescue_node(node); end - - # Visit a RestParameterNode node - sig { params(node: Prism::RestParameterNode).void } - def visit_rest_parameter_node(node); end - - # Visit a RetryNode node - sig { params(node: Prism::RetryNode).void } - def visit_retry_node(node); end - - # Visit a ReturnNode node - sig { params(node: Prism::ReturnNode).void } - def visit_return_node(node); end - - # Visit a SelfNode node - sig { params(node: Prism::SelfNode).void } - def visit_self_node(node); end - - # Visit a SingletonClassNode node - sig { params(node: Prism::SingletonClassNode).void } - def visit_singleton_class_node(node); end - - # Visit a SourceEncodingNode node - sig { params(node: Prism::SourceEncodingNode).void } - def visit_source_encoding_node(node); end - - # Visit a SourceFileNode node - sig { params(node: Prism::SourceFileNode).void } - def visit_source_file_node(node); end - - # Visit a SourceLineNode node - sig { params(node: Prism::SourceLineNode).void } - def visit_source_line_node(node); end - - # Visit a SplatNode node - sig { params(node: Prism::SplatNode).void } - def visit_splat_node(node); end - - # Visit a StatementsNode node - sig { params(node: Prism::StatementsNode).void } - def visit_statements_node(node); end - - # Visit a StringNode node - sig { params(node: Prism::StringNode).void } - def visit_string_node(node); end - - # Visit a SuperNode node - sig { params(node: Prism::SuperNode).void } - def visit_super_node(node); end - - # Visit a SymbolNode node - sig { params(node: Prism::SymbolNode).void } - def visit_symbol_node(node); end - - # Visit a TrueNode node - sig { params(node: Prism::TrueNode).void } - def visit_true_node(node); end - - # Visit a UndefNode node - sig { params(node: Prism::UndefNode).void } - def visit_undef_node(node); end - - # Visit a UnlessNode node - sig { params(node: Prism::UnlessNode).void } - def visit_unless_node(node); end - - # Visit a UntilNode node - sig { params(node: Prism::UntilNode).void } - def visit_until_node(node); end - - # Visit a WhenNode node - sig { params(node: Prism::WhenNode).void } - def visit_when_node(node); end - - # Visit a WhileNode node - sig { params(node: Prism::WhileNode).void } - def visit_while_node(node); end - - # Visit a XStringNode node - sig { params(node: Prism::XStringNode).void } - def visit_x_string_node(node); end - - # Visit a YieldNode node - sig { params(node: Prism::YieldNode).void } - def visit_yield_node(node); end -end - -class Prism::WhenNode < ::Prism::Node - def initialize(source, keyword_loc, conditions, statements, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(T::Array[Prism::Node]) } - def conditions; end - - sig { params(params: T.untyped).returns(Prism::WhenNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - class << self - def type; end - end -end - -class Prism::WhileNode < ::Prism::Node - def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Boolean) } - def begin_modifier?; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(T.nilable(String)) } - def closing; end - - sig { returns(T.nilable(Prism::Location)) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::WhileNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(Prism::Node) } - def predicate; end - - def set_newline_flag(newline_marked); end - - sig { returns(T.nilable(Prism::StatementsNode)) } - def statements; end - - def type; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::XStringNode < ::Prism::Node - include ::Prism::HeredocQuery - - def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - sig { returns(String) } - def closing; end - - sig { returns(Prism::Location) } - def closing_loc; end - - def comment_targets; end - def compact_child_nodes; end - - sig { returns(String) } - def content; end - - sig { returns(Prism::Location) } - def content_loc; end - - sig { params(params: T.untyped).returns(Prism::XStringNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 - - sig { returns(T::Boolean) } - def forced_binary_encoding?; end - - sig { returns(T::Boolean) } - def forced_utf8_encoding?; end - - def inspect(inspector = T.unsafe(nil)); end - - sig { returns(String) } - def opening; end - - sig { returns(Prism::Location) } - def opening_loc; end - - def type; end - - sig { returns(String) } - def unescaped; end - - private - - sig { returns(Integer) } - def flags; end - - class << self - def type; end - end -end - -class Prism::YieldNode < ::Prism::Node - def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, location); end - - sig { params(visitor: Prism::Visitor).void } - def accept(visitor); end - - sig { returns(T.nilable(Prism::ArgumentsNode)) } - def arguments; end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def child_nodes; end - - def comment_targets; end - def compact_child_nodes; end - - sig { params(params: T.untyped).returns(Prism::YieldNode) } - def copy(**params); end - - sig { returns(T::Array[T.nilable(Prism::Node)]) } - def deconstruct; end - - 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 = T.unsafe(nil)); end - - sig { returns(String) } - def keyword; end - - sig { returns(Prism::Location) } - def keyword_loc; end - - sig { returns(T.nilable(String)) } - def lparen; end - - sig { returns(T.nilable(Prism::Location)) } - def lparen_loc; end - - sig { returns(T.nilable(String)) } - def rparen; end - - sig { returns(T.nilable(Prism::Location)) } - def rparen_loc; end - - def type; end - - class << self - def type; end - end -end diff --git a/sorbet/rbi/gems/prism@0.29.0.rbi b/sorbet/rbi/gems/prism@0.29.0.rbi new file mode 100644 index 000000000..c21df9890 --- /dev/null +++ b/sorbet/rbi/gems/prism@0.29.0.rbi @@ -0,0 +1,14611 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `prism` gem. +# Please instead update this file by running `bin/tapioca gem prism`. + + +# typed: strict + +# =begin +# This file is generated by the templates/template.rb script and should not be +# modified manually. See templates/rbi/prism/node.rbi.erb +# if you are looking to modify the template +# =end +# =begin +# This file is generated by the templates/template.rb script and should not be +# modified manually. See templates/rbi/prism/visitor.rbi.erb +# if you are looking to modify the template +# =end + +# We keep these shims in here because our client libraries might not have parser +# in their bundle. +module Parser; end + +class Parser::Base; end + +module Prism + class << self + def dump(*_arg0); end + def dump_file(*_arg0); end + def lex(*_arg0); end + + sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) } + def lex_compat(source, **options); end + + def lex_file(*_arg0); end + + sig { params(source: String).returns(T::Array[T.untyped]) } + def lex_ripper(source); end + + sig { params(source: String, serialized: String).returns(Prism::ParseResult) } + def load(source, serialized); end + + def parse(*_arg0); end + def parse_comments(*_arg0); end + def parse_failure?(*_arg0); end + def parse_file(*_arg0); end + def parse_file_comments(*_arg0); end + def parse_file_failure?(*_arg0); end + def parse_file_success?(*_arg0); end + def parse_lex(*_arg0); end + def parse_lex_file(*_arg0); end + def parse_stream(*_arg0); end + def parse_success?(*_arg0); end + end +end + +class Prism::ASCIISource < ::Prism::Source + sig { params(byte_offset: Integer).returns(Integer) } + def character_column(byte_offset); end + + sig { params(byte_offset: Integer).returns(Integer) } + def character_offset(byte_offset); end + + sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } + def code_units_column(byte_offset, encoding); end + + sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } + def code_units_offset(byte_offset, encoding); end +end + +class Prism::AliasGlobalVariableNode < ::Prism::Node + sig do + params( + source: Prism::Source, + new_name: Prism::Node, + old_name: Prism::Node, + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, new_name, old_name, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + new_name: Prism::Node, + old_name: Prism::Node, + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::AliasGlobalVariableNode) + end + def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def new_name; end + + sig { returns(Prism::Node) } + def old_name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::AliasMethodNode < ::Prism::Node + sig do + params( + source: Prism::Source, + new_name: Prism::Node, + old_name: Prism::Node, + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, new_name, old_name, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + new_name: Prism::Node, + old_name: Prism::Node, + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::AliasMethodNode) + end + def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def new_name; end + + sig { returns(Prism::Node) } + def old_name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::AlternationPatternNode < ::Prism::Node + sig do + params( + source: Prism::Source, + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, left, right, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::AlternationPatternNode) + end + def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def left; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::AndNode < ::Prism::Node + sig do + params( + source: Prism::Source, + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, left, right, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::AndNode) + end + def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def left; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ArgumentsNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + arguments: T::Array[Prism::Node], + location: Prism::Location + ).void + end + def initialize(source, flags, arguments, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Array[Prism::Node]) } + def arguments; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T::Boolean) } + def contains_keyword_splat?; end + + sig { returns(T::Boolean) } + def contains_keywords?; end + + sig do + params( + flags: Integer, + arguments: T::Array[Prism::Node], + location: Prism::Location + ).returns(Prism::ArgumentsNode) + end + def copy(flags: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for arguments nodes. +module Prism::ArgumentsNodeFlags; end + +Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer) +Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer) + +class Prism::ArrayNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + elements: T::Array[Prism::Node], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, flags, elements, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T::Boolean) } + def contains_splat?; end + + sig do + params( + flags: Integer, + elements: T::Array[Prism::Node], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::ArrayNode) + end + def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[Prism::Node]) } + def elements; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for array nodes. +module Prism::ArrayNodeFlags; end + +Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) + +class Prism::ArrayPatternNode < ::Prism::Node + sig do + params( + source: Prism::Source, + constant: T.nilable(Prism::Node), + requireds: T::Array[Prism::Node], + rest: T.nilable(Prism::Node), + posts: T::Array[Prism::Node], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, constant, requireds, rest, posts, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::Node)) } + def constant; end + + sig do + params( + constant: T.nilable(Prism::Node), + requireds: T::Array[Prism::Node], + rest: T.nilable(Prism::Node), + posts: T::Array[Prism::Node], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::ArrayPatternNode) + end + def copy(constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T::Array[Prism::Node]) } + def posts; end + + sig { returns(T::Array[Prism::Node]) } + def requireds; end + + sig { returns(T.nilable(Prism::Node)) } + def rest; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::AssocNode < ::Prism::Node + sig do + params( + source: Prism::Source, + key: Prism::Node, + value: Prism::Node, + operator_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, key, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + key: Prism::Node, + value: Prism::Node, + operator_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::AssocNode) + end + def copy(key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def key; end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::AssocSplatNode < ::Prism::Node + sig do + params( + source: Prism::Source, + value: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + value: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::AssocSplatNode) + end + def copy(value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T.nilable(Prism::Node)) } + def value; end + + class << self + def type; end + end +end + +Prism::BACKEND = T.let(T.unsafe(nil), Symbol) + +class Prism::BackReferenceReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::BackReferenceReadNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::BasicVisitor + sig { params(node: T.nilable(Prism::Node)).void } + def visit(node); end + + sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void } + def visit_all(nodes); end + + sig { params(node: Prism::Node).void } + def visit_child_nodes(node); end +end + +class Prism::BeginNode < ::Prism::Node + sig do + params( + source: Prism::Source, + begin_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + rescue_clause: T.nilable(Prism::RescueNode), + else_clause: T.nilable(Prism::ElseNode), + ensure_clause: T.nilable(Prism::EnsureNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(String)) } + def begin_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def begin_keyword_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + begin_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + rescue_clause: T.nilable(Prism::RescueNode), + else_clause: T.nilable(Prism::ElseNode), + ensure_clause: T.nilable(Prism::EnsureNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::BeginNode) + end + def copy(begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(Prism::ElseNode)) } + def else_clause; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end + + sig { returns(T.nilable(Prism::EnsureNode)) } + def ensure_clause; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::RescueNode)) } + def rescue_clause; end + + def set_newline_flag(newline_marked); end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::BlockArgumentNode < ::Prism::Node + sig do + params( + source: Prism::Source, + expression: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, expression, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + expression: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::BlockArgumentNode) + end + def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(Prism::Node)) } + def expression; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::BlockLocalVariableNode < ::Prism::Node + sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void } + def initialize(source, flags, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) } + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::BlockNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + parameters: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, locals, parameters, body, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + locals: T::Array[Symbol], + parameters: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::BlockNode) + end + def copy(locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def parameters; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::BlockParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::BlockParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Symbol)) } + def name; end + + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::BlockParametersNode < ::Prism::Node + sig do + params( + source: Prism::Source, + parameters: T.nilable(Prism::ParametersNode), + locals: T::Array[Prism::BlockLocalVariableNode], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, parameters, locals, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + parameters: T.nilable(Prism::ParametersNode), + locals: T::Array[Prism::BlockLocalVariableNode], + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::BlockParametersNode) + end + def copy(parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Prism::BlockLocalVariableNode]) } + def locals; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T.nilable(Prism::ParametersNode)) } + def parameters; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::BreakNode < ::Prism::Node + sig do + params( + source: Prism::Source, + arguments: T.nilable(Prism::ArgumentsNode), + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, arguments, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + arguments: T.nilable(Prism::ArgumentsNode), + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::BreakNode) + end + def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::CallAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::CallAndWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Symbol) } + def read_name; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { returns(Symbol) } + def write_name; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::CallNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + name: Symbol, + message_loc: T.nilable(Prism::Location), + opening_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: T.nilable(Prism::Location), + block: T.nilable(Prism::Node), + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + name: Symbol, + message_loc: T.nilable(Prism::Location), + opening_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: T.nilable(Prism::Location), + block: T.nilable(Prism::Node), + location: Prism::Location + ).returns(Prism::CallNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T.nilable(Prism::Location)) } + def full_message_loc; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end + + sig { returns(Symbol) } + def name; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for call nodes. +module Prism::CallNodeFlags; end + +Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer) +Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer) +Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer) +Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) + +class Prism::CallOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + binary_operator: Symbol, + binary_operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + binary_operator: Symbol, + binary_operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::CallOperatorWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end + + def operator; end + def operator_loc; end + + sig { returns(Symbol) } + def read_name; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { returns(Symbol) } + def write_name; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::CallOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + message_loc: T.nilable(Prism::Location), + read_name: Symbol, + write_name: Symbol, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::CallOrWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def message; end + + sig { returns(T.nilable(Prism::Location)) } + def message_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Symbol) } + def read_name; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + sig { returns(Symbol) } + def write_name; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::CallTargetNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: Prism::Node, + call_operator_loc: Prism::Location, + name: Symbol, + message_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, name, message_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(String) } + def call_operator; end + + sig { returns(Prism::Location) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: Prism::Node, + call_operator_loc: Prism::Location, + name: Symbol, + message_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::CallTargetNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def message; end + + sig { returns(Prism::Location) } + def message_loc; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Node) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::CapturePatternNode < ::Prism::Node + sig do + params( + source: Prism::Source, + value: Prism::Node, + target: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, value, target, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + value: Prism::Node, + target: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::CapturePatternNode) + end + def copy(value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def target; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::CaseMatchNode < ::Prism::Node + sig do + params( + source: Prism::Source, + predicate: T.nilable(Prism::Node), + conditions: T::Array[Prism::Node], + consequent: T.nilable(Prism::ElseNode), + case_keyword_loc: Prism::Location, + end_keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(String) } + def case_keyword; end + + sig { returns(Prism::Location) } + def case_keyword_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T::Array[Prism::Node]) } + def conditions; end + + sig { returns(T.nilable(Prism::ElseNode)) } + def consequent; end + + sig do + params( + predicate: T.nilable(Prism::Node), + conditions: T::Array[Prism::Node], + consequent: T.nilable(Prism::ElseNode), + case_keyword_loc: Prism::Location, + end_keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::CaseMatchNode) + end + def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::Node)) } + def predicate; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::CaseNode < ::Prism::Node + sig do + params( + source: Prism::Source, + predicate: T.nilable(Prism::Node), + conditions: T::Array[Prism::Node], + consequent: T.nilable(Prism::ElseNode), + case_keyword_loc: Prism::Location, + end_keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(String) } + def case_keyword; end + + sig { returns(Prism::Location) } + def case_keyword_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T::Array[Prism::Node]) } + def conditions; end + + sig { returns(T.nilable(Prism::ElseNode)) } + def consequent; end + + sig do + params( + predicate: T.nilable(Prism::Node), + conditions: T::Array[Prism::Node], + consequent: T.nilable(Prism::ElseNode), + case_keyword_loc: Prism::Location, + end_keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::CaseNode) + end + def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::Node)) } + def predicate; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ClassNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + class_keyword_loc: Prism::Location, + constant_path: Prism::Node, + inheritance_operator_loc: T.nilable(Prism::Location), + superclass: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + name: Symbol, + location: Prism::Location + ).void + end + def initialize(source, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def class_keyword; end + + sig { returns(Prism::Location) } + def class_keyword_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(Prism::Node) } + def constant_path; end + + sig do + params( + locals: T::Array[Symbol], + class_keyword_loc: Prism::Location, + constant_path: Prism::Node, + inheritance_operator_loc: T.nilable(Prism::Location), + superclass: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + name: Symbol, + location: Prism::Location + ).returns(Prism::ClassNode) + end + def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T.nilable(String)) } + def inheritance_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def inheritance_operator_loc; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(Symbol) } + def name; end + + sig { returns(T.nilable(Prism::Node)) } + def superclass; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ClassVariableAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ClassVariableAndWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ClassVariableOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).returns(Prism::ClassVariableOperatorWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + def operator; end + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ClassVariableOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ClassVariableOrWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ClassVariableReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableReadNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ClassVariableTargetNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableTargetNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ClassVariableWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ClassVariableWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::Comment + abstract! + + sig { params(location: Prism::Location).void } + def initialize(location); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Prism::Location) } + def location; end + + sig { returns(String) } + def slice; end + + sig { abstract.returns(T::Boolean) } + def trailing?; end +end + +class Prism::Compiler < ::Prism::Visitor + sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) } + def visit(node); end + + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + + sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) } + def visit_all(nodes); end + + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + + sig { params(node: Prism::Node).returns(T::Array[T.untyped]) } + def visit_child_nodes(node); end + + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end +end + +class Prism::ConstantAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ConstantAndWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).returns(Prism::ConstantOperatorWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + def operator; end + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ConstantOrWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantPathAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, target, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ConstantPathAndWriteNode) + end + def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::ConstantPathNode) } + def target; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantPathNode < ::Prism::Node + sig do + params( + source: Prism::Source, + parent: T.nilable(Prism::Node), + name: T.nilable(Symbol), + delimiter_loc: Prism::Location, + name_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, parent, name, delimiter_loc, name_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + def child; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + parent: T.nilable(Prism::Node), + name: T.nilable(Symbol), + delimiter_loc: Prism::Location, + name_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ConstantPathNode) + end + def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def delimiter; end + + sig { returns(Prism::Location) } + def delimiter_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def full_name; end + + sig { returns(T::Array[Symbol]) } + def full_name_parts; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Symbol)) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def parent; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end +class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError; end + +class Prism::ConstantPathOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + target: Prism::ConstantPathNode, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).void + end + def initialize(source, target, binary_operator_loc, value, binary_operator, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + target: Prism::ConstantPathNode, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).returns(Prism::ConstantPathOperatorWriteNode) + end + def copy(target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + def operator; end + def operator_loc; end + + sig { returns(Prism::ConstantPathNode) } + def target; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantPathOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, target, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ConstantPathOrWriteNode) + end + def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::ConstantPathNode) } + def target; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantPathTargetNode < ::Prism::Node + sig do + params( + source: Prism::Source, + parent: T.nilable(Prism::Node), + name: T.nilable(Symbol), + delimiter_loc: Prism::Location, + name_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, parent, name, delimiter_loc, name_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + def child; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + parent: T.nilable(Prism::Node), + name: T.nilable(Symbol), + delimiter_loc: Prism::Location, + name_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ConstantPathTargetNode) + end + def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def delimiter; end + + sig { returns(Prism::Location) } + def delimiter_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def full_name; end + + sig { returns(T::Array[Symbol]) } + def full_name_parts; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Symbol)) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def parent; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ConstantPathWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, target, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + target: Prism::ConstantPathNode, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::ConstantPathWriteNode) + end + def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::ConstantPathNode) } + def target; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ConstantReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantReadNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def full_name; end + + sig { returns(T::Array[Symbol]) } + def full_name_parts; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ConstantTargetNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantTargetNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def full_name; end + + sig { returns(T::Array[Symbol]) } + def full_name_parts; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ConstantWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ConstantWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def full_name; end + + sig { returns(T::Array[Symbol]) } + def full_name_parts; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +module Prism::DSL + private + + def AliasGlobalVariableNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def AliasMethodNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def AlternationPatternNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def AndNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ArgumentsNode(flags, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ArrayNode(flags, elements, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def AssocNode(key, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def AssocSplatNode(value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BackReferenceReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BlockArgumentNode(expression, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BlockLocalVariableNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BlockNode(locals, parameters, body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BlockParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BlockParametersNode(parameters, locals, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def BreakNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CapturePatternNode(value, target, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ClassVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathAndWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathOperatorWriteNode(target, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathOrWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathTargetNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantPathWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ConstantWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ElseNode(else_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def EmbeddedStatementsNode(opening_loc, statements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def EmbeddedVariableNode(operator_loc, variable, source = T.unsafe(nil), location = T.unsafe(nil)); end + def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def FalseNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def FlipFlopNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def FloatNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ForwardingArgumentsNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def ForwardingParameterNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def ForwardingSuperNode(block, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def GlobalVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def HashNode(opening_loc, elements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ImaginaryNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ImplicitNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ImplicitRestNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def InNode(pattern, statements, in_loc, then_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InstanceVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def IntegerNode(flags, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InterpolatedStringNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InterpolatedSymbolNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def InterpolatedXStringNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ItParametersNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def KeywordHashNode(flags, elements, source = T.unsafe(nil), location = T.unsafe(nil)); end + def KeywordRestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableOperatorWriteNode(name_loc, binary_operator_loc, value, name, binary_operator, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableReadNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableTargetNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end + def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end + def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MatchPredicateNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MatchRequiredNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MatchWriteNode(call, targets, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MissingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def NextNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def NilNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def NoKeywordsParameterNode(operator_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def NumberedParametersNode(maximum, source = T.unsafe(nil), location = T.unsafe(nil)); end + def NumberedReferenceReadNode(number, source = T.unsafe(nil), location = T.unsafe(nil)); end + def OptionalKeywordParameterNode(flags, name, name_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def OptionalParameterNode(flags, name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end + def OrNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ParenthesesNode(body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def PinnedVariableNode(variable, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def ProgramNode(locals, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RangeNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RationalNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RedoNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RequiredKeywordParameterNode(flags, name, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RequiredParameterNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RescueModifierNode(expression, keyword_loc, rescue_expression, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def RetryNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def ReturnNode(flags, keyword_loc, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SelfNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def ShareableConstantNode(flags, write, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SourceEncodingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def SourceFileNode(flags, filepath, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SourceLineNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def SplatNode(operator_loc, expression, source = T.unsafe(nil), location = T.unsafe(nil)); end + def StatementsNode(body, source = T.unsafe(nil), location = T.unsafe(nil)); end + def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end + def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end + def TrueNode(source = T.unsafe(nil), location = T.unsafe(nil)); end + def UndefNode(names, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end + def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end + def WhenNode(keyword_loc, conditions, then_keyword_loc, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end + def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end + def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end + def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end +end + +module Prism::Debug + class << self + def cruby_locals(source); end + def format_errors(_arg0, _arg1); end + def inspect_node(_arg0); end + def integer_parse(_arg0); end + def memsize(_arg0); end + def named_captures(_arg0); end + def newlines(source); end + def prism_locals(source); end + def profile_file(_arg0); end + def static_inspect(*_arg0); end + end +end + +Prism::Debug::AnonymousLocal = T.let(T.unsafe(nil), Object) + +class Prism::Debug::Encoding + def initialize(name, multibyte); end + + def alnum?(source); end + def alpha?(source); end + def multibyte?; end + def name; end + def upper?(source); end + def width(source); end + + class << self + def _alnum?(_arg0, _arg1); end + def _alpha?(_arg0, _arg1); end + def _upper?(_arg0, _arg1); end + def _width(_arg0, _arg1); end + def all; end + end +end + +class Prism::Debug::ISeq + def initialize(parts); end + + def each_child; end + def instructions; end + def local_table; end + def parts; end + def type; end +end + +class Prism::DefNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + receiver: T.nilable(Prism::Node), + parameters: T.nilable(Prism::ParametersNode), + body: T.nilable(Prism::Node), + locals: T::Array[Symbol], + def_keyword_loc: Prism::Location, + operator_loc: T.nilable(Prism::Location), + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + equal_loc: T.nilable(Prism::Location), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + receiver: T.nilable(Prism::Node), + parameters: T.nilable(Prism::ParametersNode), + body: T.nilable(Prism::Node), + locals: T::Array[Symbol], + def_keyword_loc: Prism::Location, + operator_loc: T.nilable(Prism::Location), + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + equal_loc: T.nilable(Prism::Location), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::DefNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def def_keyword; end + + sig { returns(Prism::Location) } + def def_keyword_loc; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end + + sig { returns(T.nilable(String)) } + def equal; end + + sig { returns(T.nilable(Prism::Location)) } + def equal_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end + + sig { returns(T.nilable(Prism::ParametersNode)) } + def parameters; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::DefinedNode < ::Prism::Node + sig do + params( + source: Prism::Source, + lparen_loc: T.nilable(Prism::Location), + value: Prism::Node, + rparen_loc: T.nilable(Prism::Location), + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, lparen_loc, value, rparen_loc, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + lparen_loc: T.nilable(Prism::Location), + value: Prism::Node, + rparen_loc: T.nilable(Prism::Location), + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::DefinedNode) + end + def copy(lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::DesugarAndWriteNode + def initialize(node, source, read_class, write_class, *arguments); end + + def arguments; end + def compile; end + def node; end + def read_class; end + def source; end + def write_class; end +end + +class Prism::DesugarCompiler < ::Prism::MutationCompiler + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end +end + +class Prism::DesugarOperatorWriteNode + def initialize(node, source, read_class, write_class, *arguments); end + + def arguments; end + def compile; end + def node; end + def read_class; end + def source; end + def write_class; end +end + +class Prism::DesugarOrWriteDefinedNode + def initialize(node, source, read_class, write_class, *arguments); end + + def arguments; end + def compile; end + def node; end + def read_class; end + def source; end + def write_class; end +end + +class Prism::DesugarOrWriteNode + def initialize(node, source, read_class, write_class, *arguments); end + + def arguments; end + def compile; end + def node; end + def read_class; end + def source; end + def write_class; end +end + +class Prism::Dispatcher < ::Prism::Visitor + def initialize; end + + def dispatch(node); end + def dispatch_once(node); end + def listeners; end + def register(listener, *events); end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end +end + +class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor + def initialize(listeners); end + + def listeners; end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end +end + +class Prism::DotVisitor < ::Prism::Visitor + def initialize; end + + def digraph; end + def to_dot; end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end + + private + + def arguments_node_flags_inspect(node); end + def array_node_flags_inspect(node); end + def call_node_flags_inspect(node); end + def encoding_flags_inspect(node); end + def integer_base_flags_inspect(node); end + def interpolated_string_node_flags_inspect(node); end + def keyword_hash_node_flags_inspect(node); end + def location_inspect(location); end + def loop_flags_inspect(node); end + def node_id(node); end + def parameter_flags_inspect(node); end + def range_flags_inspect(node); end + def regular_expression_flags_inspect(node); end + def return_node_flags_inspect(node); end + def shareable_constant_node_flags_inspect(node); end + def string_flags_inspect(node); end + def symbol_flags_inspect(node); end +end + +class Prism::DotVisitor::Digraph + def initialize; end + + def edge(value); end + def edges; end + def node(value); end + def nodes; end + def to_dot; end + def waypoint(value); end + def waypoints; end +end + +class Prism::DotVisitor::Field + def initialize(name, value, port); end + + def name; end + def port; end + def to_dot; end + def value; end +end + +class Prism::DotVisitor::Table + def initialize(name); end + + def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end + def fields; end + def name; end + def to_dot; end +end + +class Prism::ElseNode < ::Prism::Node + sig do + params( + source: Prism::Source, + else_keyword_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, else_keyword_loc, statements, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + else_keyword_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::ElseNode) + end + def copy(else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def else_keyword; end + + sig { returns(Prism::Location) } + def else_keyword_loc; end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::EmbDocComment < ::Prism::Comment + sig { returns(String) } + def inspect; end + + sig { override.returns(T::Boolean) } + def trailing?; end +end + +class Prism::EmbeddedStatementsNode < ::Prism::Node + sig do + params( + source: Prism::Source, + opening_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, opening_loc, statements, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + opening_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::EmbeddedStatementsNode) + end + def copy(opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::EmbeddedVariableNode < ::Prism::Node + sig do + params( + source: Prism::Source, + operator_loc: Prism::Location, + variable: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, operator_loc, variable, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + operator_loc: Prism::Location, + variable: Prism::Node, + location: Prism::Location + ).returns(Prism::EmbeddedVariableNode) + end + def copy(operator_loc: T.unsafe(nil), variable: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def variable; end + + class << self + def type; end + end +end + +# Flags for nodes that have unescaped content. +module Prism::EncodingFlags; end + +Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) + +class Prism::EnsureNode < ::Prism::Node + sig do + params( + source: Prism::Source, + ensure_keyword_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, ensure_keyword_loc, statements, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + ensure_keyword_loc: Prism::Location, + statements: T.nilable(Prism::StatementsNode), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::EnsureNode) + end + def copy(ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { returns(String) } + def ensure_keyword; end + + sig { returns(Prism::Location) } + def ensure_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::FalseNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::FalseNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::FindPatternNode < ::Prism::Node + sig do + params( + source: Prism::Source, + constant: T.nilable(Prism::Node), + left: Prism::Node, + requireds: T::Array[Prism::Node], + right: Prism::Node, + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, constant, left, requireds, right, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::Node)) } + def constant; end + + sig do + params( + constant: T.nilable(Prism::Node), + left: Prism::Node, + requireds: T::Array[Prism::Node], + right: Prism::Node, + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::FindPatternNode) + end + def copy(constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def left; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T::Array[Prism::Node]) } + def requireds; end + + sig { returns(Prism::Node) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::FlipFlopNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + left: T.nilable(Prism::Node), + right: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, left, right, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + left: T.nilable(Prism::Node), + right: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::FlipFlopNode) + end + def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def exclude_end?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::Node)) } + def left; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::FloatNode < ::Prism::Node + sig { params(source: Prism::Source, value: Float, location: Prism::Location).void } + def initialize(source, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(value: Float, location: Prism::Location).returns(Prism::FloatNode) } + def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Float) } + def value; end + + class << self + def type; end + end +end + +class Prism::ForNode < ::Prism::Node + sig do + params( + source: Prism::Source, + index: Prism::Node, + collection: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + for_keyword_loc: Prism::Location, + in_keyword_loc: Prism::Location, + do_keyword_loc: T.nilable(Prism::Location), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(Prism::Node) } + def collection; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + index: Prism::Node, + collection: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + for_keyword_loc: Prism::Location, + in_keyword_loc: Prism::Location, + do_keyword_loc: T.nilable(Prism::Location), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ForNode) + end + def copy(index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def do_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def do_keyword_loc; end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def for_keyword; end + + sig { returns(Prism::Location) } + def for_keyword_loc; end + + sig { returns(String) } + def in_keyword; end + + sig { returns(Prism::Location) } + def in_keyword_loc; end + + sig { returns(Prism::Node) } + def index; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ForwardingArgumentsNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::ForwardingArgumentsNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ForwardingParameterNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::ForwardingParameterNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ForwardingSuperNode < ::Prism::Node + sig { params(source: Prism::Source, block: T.nilable(Prism::BlockNode), location: Prism::Location).void } + def initialize(source, block, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::BlockNode)) } + def block; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).returns(Prism::ForwardingSuperNode) } + def copy(block: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::GlobalVariableAndWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).returns(Prism::GlobalVariableOperatorWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + def operator; end + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::GlobalVariableOrWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableReadNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableTargetNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableTargetNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::GlobalVariableWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::GlobalVariableWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::HashNode < ::Prism::Node + sig do + params( + source: Prism::Source, + opening_loc: Prism::Location, + elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, opening_loc, elements, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + opening_loc: Prism::Location, + elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::HashNode) + end + def copy(opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) } + def elements; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::HashPatternNode < ::Prism::Node + sig do + params( + source: Prism::Source, + constant: T.nilable(Prism::Node), + elements: T::Array[Prism::AssocNode], + rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)), + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, constant, elements, rest, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::Node)) } + def constant; end + + sig do + params( + constant: T.nilable(Prism::Node), + elements: T::Array[Prism::AssocNode], + rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)), + opening_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::HashPatternNode) + end + def copy(constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[Prism::AssocNode]) } + def elements; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode))) } + def rest; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +module Prism::HeredocQuery + def heredoc?; end +end + +class Prism::IfNode < ::Prism::Node + sig do + params( + source: Prism::Source, + if_keyword_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::Node), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::Node)) } + def consequent; end + + sig do + params( + if_keyword_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::Node), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::IfNode) + end + def copy(if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T.nilable(String)) } + def if_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def if_keyword_loc; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def predicate; end + + def set_newline_flag(newline_marked); end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { returns(T.nilable(String)) } + def then_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def then_keyword_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ImaginaryNode < ::Prism::Node + sig do + params( + source: Prism::Source, + numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode), + location: Prism::Location + ).void + end + def initialize(source, numeric, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode), + location: Prism::Location + ).returns(Prism::ImaginaryNode) + end + def copy(numeric: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)) } + def numeric; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Complex) } + def value; end + + class << self + def type; end + end +end + +class Prism::ImplicitNode < ::Prism::Node + sig { params(source: Prism::Source, value: Prism::Node, location: Prism::Location).void } + def initialize(source, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(value: Prism::Node, location: Prism::Location).returns(Prism::ImplicitNode) } + def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::ImplicitRestNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::ImplicitRestNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::InNode < ::Prism::Node + sig do + params( + source: Prism::Source, + pattern: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + in_loc: Prism::Location, + then_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, pattern, statements, in_loc, then_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + pattern: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + in_loc: Prism::Location, + then_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::InNode) + end + def copy(pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def in; end + + sig { returns(Prism::Location) } + def in_loc; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def pattern; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { returns(T.nilable(String)) } + def then; end + + sig { returns(T.nilable(Prism::Location)) } + def then_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::IndexAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::IndexAndWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::IndexOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + binary_operator: Symbol, + binary_operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + binary_operator: Symbol, + binary_operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::IndexOperatorWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + def operator; end + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::IndexOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { returns(T.nilable(String)) } + def call_operator; end + + sig { returns(T.nilable(Prism::Location)) } + def call_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: T.nilable(Prism::Node), + call_operator_loc: T.nilable(Prism::Location), + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::IndexOrWriteNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::IndexTargetNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + receiver: Prism::Node, + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + location: Prism::Location + ).void + end + def initialize(source, flags, receiver, opening_loc, arguments, closing_loc, block, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T::Boolean) } + def attribute_write?; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + receiver: Prism::Node, + opening_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + closing_loc: Prism::Location, + block: T.nilable(Prism::Node), + location: Prism::Location + ).returns(Prism::IndexTargetNode) + end + def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def ignore_visibility?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Prism::Node) } + def receiver; end + + sig { returns(T::Boolean) } + def safe_navigation?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T::Boolean) } + def variable_call?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::InlineComment < ::Prism::Comment + sig { returns(String) } + def inspect; end + + sig { override.returns(T::Boolean) } + def trailing?; end +end + +class Prism::InspectVisitor < ::Prism::Visitor + sig { params(indent: String).void } + def initialize(indent = T.unsafe(nil)); end + + def commands; end + + sig { returns(String) } + def compose; end + + def indent; end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end + + private + + def inspect_location(location); end + def inspect_node(name, node); end + + class << self + sig { params(node: Prism::Node).returns(String) } + def compose(node); end + end +end + +class Prism::InspectVisitor::Replace + def initialize(value); end + + def value; end +end + +class Prism::InstanceVariableAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::InstanceVariableAndWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + binary_operator: Symbol, + location: Prism::Location + ).returns(Prism::InstanceVariableOperatorWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + def operator; end + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::InstanceVariableOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::InstanceVariableOrWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::InstanceVariableReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableReadNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::InstanceVariableTargetNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void } + def initialize(source, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableTargetNode) } + def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::InstanceVariableWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, name, name_loc, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::InstanceVariableWriteNode) + end + def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +# Flags for integer nodes that correspond to the base of the integer. +module Prism::IntegerBaseFlags; end + +Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer) +Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer) +Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer) +Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer) + +class Prism::IntegerNode < ::Prism::Node + sig { params(source: Prism::Source, flags: Integer, value: Integer, location: Prism::Location).void } + def initialize(source, flags, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def binary?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(flags: Integer, value: Integer, location: Prism::Location).returns(Prism::IntegerNode) } + def copy(flags: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { returns(T::Boolean) } + def decimal?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def hexadecimal?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def octal?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Integer) } + def value; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::InterpolatedMatchLastLineNode < ::Prism::Node + include ::Prism::RegularExpressionOptions + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, parts, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::InterpolatedMatchLastLineNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_us_ascii_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Integer) } + def options; end + + sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } + def parts; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::InterpolatedRegularExpressionNode < ::Prism::Node + include ::Prism::RegularExpressionOptions + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, parts, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::InterpolatedRegularExpressionNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_us_ascii_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Integer) } + def options; end + + sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } + def parts; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::InterpolatedStringNode < ::Prism::Node + include ::Prism::HeredocQuery + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: T.nilable(Prism::Location), + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)], + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, parts, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + opening_loc: T.nilable(Prism::Location), + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)], + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::InterpolatedStringNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def frozen?; end + + sig { returns(T::Boolean) } + def heredoc?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def mutable?; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig do + returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)]) + end + def parts; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for interpolated string nodes that indicated mutability if they are also marked as literals. +module Prism::InterpolatedStringNodeFlags; end + +Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer) +Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer) + +class Prism::InterpolatedSymbolNode < ::Prism::Node + sig do + params( + source: Prism::Source, + opening_loc: T.nilable(Prism::Location), + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, opening_loc, parts, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + opening_loc: T.nilable(Prism::Location), + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::InterpolatedSymbolNode) + end + def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } + def parts; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::InterpolatedXStringNode < ::Prism::Node + include ::Prism::HeredocQuery + + sig do + params( + source: Prism::Source, + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, opening_loc, parts, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + opening_loc: Prism::Location, + parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)], + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::InterpolatedXStringNode) + end + def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def heredoc?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } + def parts; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ItParametersNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::ItParametersNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::KeywordHashNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)], + location: Prism::Location + ).void + end + def initialize(source, flags, elements, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)], + location: Prism::Location + ).returns(Prism::KeywordHashNode) + end + def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) } + def elements; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def symbol_keys?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for keyword hash nodes. +module Prism::KeywordHashNodeFlags; end + +Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer) + +class Prism::KeywordRestParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::KeywordRestParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Symbol)) } + def name; end + + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::LambdaNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + operator_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + parameters: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + location: Prism::Location + ).void + end + def initialize(source, locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + locals: T::Array[Symbol], + operator_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + parameters: T.nilable(Prism::Node), + body: T.nilable(Prism::Node), + location: Prism::Location + ).returns(Prism::LambdaNode) + end + def copy(locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def parameters; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::LexCompat + def initialize(source, **options); end + + def options; end + def result; end + def source; end +end + +class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token + def ==(other); end +end + +module Prism::LexCompat::Heredoc + class << self + def build(opening); end + end +end + +class Prism::LexCompat::Heredoc::DashHeredoc + def initialize(split); end + + def <<(token); end + def split; end + def to_a; end + def tokens; end +end + +class Prism::LexCompat::Heredoc::DedentingHeredoc + def initialize; end + + def <<(token); end + def dedent; end + def dedent_next; end + def embexpr_balance; end + def to_a; end + def tokens; end +end + +Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer) + +class Prism::LexCompat::Heredoc::PlainHeredoc + def initialize; end + + def <<(token); end + def to_a; end + def tokens; end +end + +class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token + def ==(other); end +end + +class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token + def ==(other); end +end + +class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token + def ==(other); end +end + +class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token + def ==(other); end +end + +Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash) + +class Prism::LexCompat::Result < ::Prism::Result + def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end + + def deconstruct_keys(keys); end + def value; end +end + +class Prism::LexCompat::Token < ::SimpleDelegator + def event; end + def location; end + def state; end + def value; end +end + +class Prism::LexResult < ::Prism::Result + sig do + params( + value: T::Array[T.untyped], + comments: T::Array[Prism::Comment], + magic_comments: T::Array[Prism::MagicComment], + data_loc: T.nilable(Prism::Location), + errors: T::Array[Prism::ParseError], + warnings: T::Array[Prism::ParseWarning], + source: Prism::Source + ).void + end + def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[T.untyped]) } + def value; end +end + +class Prism::LexRipper + def initialize(source); end + + def result; end + def source; end + + private + + def lex(source); end +end + +class Prism::LocalVariableAndWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + depth: Integer, + location: Prism::Location + ).void + end + def initialize(source, name_loc, operator_loc, value, name, depth, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + depth: Integer, + location: Prism::Location + ).returns(Prism::LocalVariableAndWriteNode) + end + def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::LocalVariableOperatorWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + binary_operator: Symbol, + depth: Integer, + location: Prism::Location + ).void + end + def initialize(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Symbol) } + def binary_operator; end + + sig { returns(Prism::Location) } + def binary_operator_loc; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name_loc: Prism::Location, + binary_operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + binary_operator: Symbol, + depth: Integer, + location: Prism::Location + ).returns(Prism::LocalVariableOperatorWriteNode) + end + def copy(name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + def operator; end + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::LocalVariableOrWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + depth: Integer, + location: Prism::Location + ).void + end + def initialize(source, name_loc, operator_loc, value, name, depth, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + name: Symbol, + depth: Integer, + location: Prism::Location + ).returns(Prism::LocalVariableOrWriteNode) + end + def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + def desugar; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::LocalVariableReadNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(source, name, depth, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableReadNode) } + def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::LocalVariableTargetNode < ::Prism::Node + sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void } + def initialize(source, name, depth, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableTargetNode) } + def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::LocalVariableWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + name: Symbol, + depth: Integer, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, name, depth, name_loc, value, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + name: Symbol, + depth: Integer, + name_loc: Prism::Location, + value: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::LocalVariableWriteNode) + end + def copy(name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def depth; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::Location + sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void } + def initialize(source, start_offset, length); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def ==(other); end + + sig { params(string: String).returns(Prism::Location) } + def adjoin(string); end + + sig { returns(Prism::Location) } + def chop; end + + sig { returns(T::Array[Prism::Comment]) } + def comments; end + + sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) } + def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Integer) } + def end_character_column; end + + sig { returns(Integer) } + def end_character_offset; end + + sig { params(encoding: Encoding).returns(Integer) } + def end_code_units_column(encoding = T.unsafe(nil)); end + + sig { params(encoding: Encoding).returns(Integer) } + def end_code_units_offset(encoding = T.unsafe(nil)); end + + sig { returns(Integer) } + def end_column; end + + sig { returns(Integer) } + def end_line; end + + sig { returns(Integer) } + def end_offset; end + + sig { returns(String) } + def inspect; end + + sig { params(other: Prism::Location).returns(Prism::Location) } + def join(other); end + + sig { params(comment: Prism::Comment).void } + def leading_comment(comment); end + + sig { returns(T::Array[Prism::Comment]) } + def leading_comments; end + + sig { returns(Integer) } + def length; end + + sig { params(q: T.untyped).void } + def pretty_print(q); end + + sig { returns(String) } + def slice; end + + def slice_lines; end + + sig { returns(T::Array[String]) } + def source_lines; end + + sig { returns(Integer) } + def start_character_column; end + + sig { returns(Integer) } + def start_character_offset; end + + sig { params(encoding: Encoding).returns(Integer) } + def start_code_units_column(encoding = T.unsafe(nil)); end + + sig { params(encoding: Encoding).returns(Integer) } + def start_code_units_offset(encoding = T.unsafe(nil)); end + + sig { returns(Integer) } + def start_column; end + + sig { returns(Integer) } + def start_line; end + + sig { returns(String) } + def start_line_slice; end + + sig { returns(Integer) } + def start_offset; end + + sig { params(comment: Prism::Comment).void } + def trailing_comment(comment); end + + sig { returns(T::Array[Prism::Comment]) } + def trailing_comments; end + + protected + + sig { returns(Prism::Source) } + def source; end +end + +# Flags for while and until loop nodes. +module Prism::LoopFlags; end + +Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer) + +class Prism::MagicComment + sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void } + def initialize(key_loc, value_loc); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def inspect; end + + sig { returns(String) } + def key; end + + sig { returns(Prism::Location) } + def key_loc; end + + sig { returns(String) } + def value; end + + sig { returns(Prism::Location) } + def value_loc; end +end + +class Prism::MatchLastLineNode < ::Prism::Node + include ::Prism::RegularExpressionOptions + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(String) } + def content; end + + sig { returns(Prism::Location) } + def content_loc; end + + sig do + params( + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).returns(Prism::MatchLastLineNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_us_ascii_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Integer) } + def options; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(String) } + def unescaped; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::MatchPredicateNode < ::Prism::Node + sig do + params( + source: Prism::Source, + value: Prism::Node, + pattern: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, value, pattern, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + value: Prism::Node, + pattern: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::MatchPredicateNode) + end + def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def pattern; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::MatchRequiredNode < ::Prism::Node + sig do + params( + source: Prism::Source, + value: Prism::Node, + pattern: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, value, pattern, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + value: Prism::Node, + pattern: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::MatchRequiredNode) + end + def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def pattern; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::MatchWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + call: Prism::CallNode, + targets: T::Array[Prism::LocalVariableTargetNode], + location: Prism::Location + ).void + end + def initialize(source, call, targets, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(Prism::CallNode) } + def call; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + call: Prism::CallNode, + targets: T::Array[Prism::LocalVariableTargetNode], + location: Prism::Location + ).returns(Prism::MatchWriteNode) + end + def copy(call: T.unsafe(nil), targets: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Prism::LocalVariableTargetNode]) } + def targets; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::MissingNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::MissingNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ModuleNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + module_keyword_loc: Prism::Location, + constant_path: Prism::Node, + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + name: Symbol, + location: Prism::Location + ).void + end + def initialize(source, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(Prism::Node) } + def constant_path; end + + sig do + params( + locals: T::Array[Symbol], + module_keyword_loc: Prism::Location, + constant_path: Prism::Node, + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + name: Symbol, + location: Prism::Location + ).returns(Prism::ModuleNode) + end + def copy(locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(String) } + def module_keyword; end + + sig { returns(Prism::Location) } + def module_keyword_loc; end + + sig { returns(Symbol) } + def name; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::MultiTargetNode < ::Prism::Node + sig do + params( + source: Prism::Source, + lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)], + rest: T.nilable(Prism::Node), + rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)], + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)], + rest: T.nilable(Prism::Node), + rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)], + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::MultiTargetNode) + end + def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig do + returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)]) + end + def lefts; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def rest; end + + sig do + returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)]) + end + def rights; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::MultiWriteNode < ::Prism::Node + sig do + params( + source: Prism::Source, + lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)], + rest: T.nilable(Prism::Node), + rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)], + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)], + rest: T.nilable(Prism::Node), + rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)], + lparen_loc: T.nilable(Prism::Location), + rparen_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::MultiWriteNode) + end + def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig do + returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)]) + end + def lefts; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def rest; end + + sig do + returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)]) + end + def rights; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + class << self + def type; end + end +end + +class Prism::MutationCompiler < ::Prism::Compiler + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end +end + +class Prism::NextNode < ::Prism::Node + sig do + params( + source: Prism::Source, + arguments: T.nilable(Prism::ArgumentsNode), + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, arguments, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + arguments: T.nilable(Prism::ArgumentsNode), + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::NextNode) + end + def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::NilNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::NilNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::NoKeywordsParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + operator_loc: Prism::Location, + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, operator_loc, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + operator_loc: Prism::Location, + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::NoKeywordsParameterNode) + end + def copy(operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::Node + abstract! + + sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { abstract.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + def deprecated(*replacements); end + + sig { returns(Integer) } + def end_offset; end + + sig { abstract.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { abstract.returns(String) } + def inspect; end + + sig { returns(Prism::Location) } + def location; end + + def newline?; end + + sig { params(q: T.untyped).void } + def pretty_print(q); end + + sig { returns(T::Array[String]) } + def script_lines; end + + def set_newline_flag(newline_marked); end + + sig { returns(String) } + def slice; end + + sig { returns(String) } + def slice_lines; end + + sig { returns(T::Array[String]) } + def source_lines; end + + sig { returns(Integer) } + def start_offset; end + + sig { returns(String) } + def to_dot; end + + sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) } + def tunnel(line, column); end + + sig { abstract.returns(Symbol) } + def type; end + + private + + sig { returns(Prism::Source) } + def source; end + + class << self + def fields; end + def type; end + end +end + +class Prism::NumberedParametersNode < ::Prism::Node + sig { params(source: Prism::Source, maximum: Integer, location: Prism::Location).void } + def initialize(source, maximum, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(maximum: Integer, location: Prism::Location).returns(Prism::NumberedParametersNode) } + def copy(maximum: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Integer) } + def maximum; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::NumberedReferenceReadNode < ::Prism::Node + sig { params(source: Prism::Source, number: Integer, location: Prism::Location).void } + def initialize(source, number, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(number: Integer, location: Prism::Location).returns(Prism::NumberedReferenceReadNode) } + def copy(number: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Integer) } + def number; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::OptionalKeywordParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::OptionalKeywordParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::OptionalParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, operator_loc, value, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + operator_loc: Prism::Location, + value: Prism::Node, + location: Prism::Location + ).returns(Prism::OptionalParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def value; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::OrNode < ::Prism::Node + sig do + params( + source: Prism::Source, + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, left, right, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + left: Prism::Node, + right: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::OrNode) + end + def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def left; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(Prism::Node) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +module Prism::Pack + class << self + def parse(_arg0, _arg1, _arg2); end + end +end + +Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol) +Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol) +Prism::Pack::BER = T.let(T.unsafe(nil), Symbol) +Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol) +Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol) + +class Prism::Pack::Directive + def initialize(version, variant, source, type, signed, endian, size, length_type, length); end + + def describe; end + def endian; end + def length; end + def length_type; end + def signed; end + def size; end + def source; end + def type; end + def variant; end + def version; end +end + +Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) +Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) +Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash) +Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol) +Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol) + +class Prism::Pack::Format + def initialize(directives, encoding); end + + def describe; end + def directives; end + def encoding; end +end + +Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol) +Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol) +Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol) +Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol) +Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol) +Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol) +Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol) +Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol) +Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol) +Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol) +Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol) + +# Flags for parameter nodes. +module Prism::ParameterFlags; end + +Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer) + +class Prism::ParametersNode < ::Prism::Node + sig do + params( + source: Prism::Source, + requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], + optionals: T::Array[Prism::OptionalParameterNode], + rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), + posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)], + keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], + keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), + block: T.nilable(Prism::BlockParameterNode), + location: Prism::Location + ).void + end + def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::BlockParameterNode)) } + def block; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], + optionals: T::Array[Prism::OptionalParameterNode], + rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), + posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)], + keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], + keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), + block: T.nilable(Prism::BlockParameterNode), + location: Prism::Location + ).returns(Prism::ParametersNode) + end + def copy(requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig do + returns(T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode))) + end + def keyword_rest; end + + sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) } + def keywords; end + + sig { returns(T::Array[Prism::OptionalParameterNode]) } + def optionals; end + + sig do + returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)]) + end + def posts; end + + sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)]) } + def requireds; end + + sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) } + def rest; end + + sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) } + def signature; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ParenthesesNode < ::Prism::Node + sig do + params( + source: Prism::Source, + body: T.nilable(Prism::Node), + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, body, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + body: T.nilable(Prism::Node), + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::ParenthesesNode) + end + def copy(body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ParseError + sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void } + def initialize(type, message, location, level); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def inspect; end + + sig { returns(Symbol) } + def level; end + + sig { returns(Prism::Location) } + def location; end + + sig { returns(String) } + def message; end + + sig { returns(Symbol) } + def type; end +end + +class Prism::ParseLexResult < ::Prism::Result + sig do + params( + value: [Prism::ProgramNode, T::Array[T.untyped]], + comments: T::Array[Prism::Comment], + magic_comments: T::Array[Prism::MagicComment], + data_loc: T.nilable(Prism::Location), + errors: T::Array[Prism::ParseError], + warnings: T::Array[Prism::ParseWarning], + source: Prism::Source + ).void + end + def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) } + def value; end +end + +class Prism::ParseResult < ::Prism::Result + sig do + params( + value: Prism::ProgramNode, + comments: T::Array[Prism::Comment], + magic_comments: T::Array[Prism::MagicComment], + data_loc: T.nilable(Prism::Location), + errors: T::Array[Prism::ParseError], + warnings: T::Array[Prism::ParseWarning], + source: Prism::Source + ).void + end + def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end + + def attach_comments!; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + def mark_newlines!; end + + sig { returns(Prism::ProgramNode) } + def value; end +end + +class Prism::ParseResult::Comments + def initialize(parse_result); end + + def attach!; end + def parse_result; end + + private + + def nearest_targets(node, comment); end +end + +class Prism::ParseResult::Comments::LocationTarget + def initialize(location); end + + def encloses?(comment); end + def end_offset; end + def leading_comment(comment); end + def location; end + def start_offset; end + def trailing_comment(comment); end +end + +class Prism::ParseResult::Comments::NodeTarget + def initialize(node); end + + def encloses?(comment); end + def end_offset; end + def leading_comment(comment); end + def node; end + def start_offset; end + def trailing_comment(comment); end +end + +class Prism::ParseResult::Newlines < ::Prism::Visitor + def initialize(newline_marked); end + + def visit_block_node(node); end + def visit_if_node(node); end + def visit_lambda_node(node); end + def visit_statements_node(node); end + def visit_unless_node(node); end +end + +class Prism::ParseWarning + sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void } + def initialize(type, message, location, level); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def inspect; end + + sig { returns(Symbol) } + def level; end + + sig { returns(Prism::Location) } + def location; end + + sig { returns(String) } + def message; end + + sig { returns(Symbol) } + def type; end +end + +class Prism::Pattern + def initialize(query); end + + def compile; end + def query; end + def scan(root); end + + private + + def combine_and(left, right); end + def combine_or(left, right); end + def compile_alternation_pattern_node(node); end + def compile_array_pattern_node(node); end + def compile_constant_name(node, name); end + def compile_constant_path_node(node); end + def compile_constant_read_node(node); end + def compile_error(node); end + def compile_hash_pattern_node(node); end + def compile_nil_node(node); end + def compile_node(node); end + def compile_regular_expression_node(node); end + def compile_string_node(node); end + def compile_symbol_node(node); end +end + +class Prism::Pattern::CompilationError < ::StandardError + def initialize(repr); end +end + +class Prism::PinnedExpressionNode < ::Prism::Node + sig do + params( + source: Prism::Source, + expression: Prism::Node, + operator_loc: Prism::Location, + lparen_loc: Prism::Location, + rparen_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, expression, operator_loc, lparen_loc, rparen_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + expression: Prism::Node, + operator_loc: Prism::Location, + lparen_loc: Prism::Location, + rparen_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::PinnedExpressionNode) + end + def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Prism::Node) } + def expression; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def lparen; end + + sig { returns(Prism::Location) } + def lparen_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(String) } + def rparen; end + + sig { returns(Prism::Location) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::PinnedVariableNode < ::Prism::Node + sig do + params( + source: Prism::Source, + variable: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, variable, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + variable: Prism::Node, + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::PinnedVariableNode) + end + def copy(variable: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Prism::Node) } + def variable; end + + class << self + def type; end + end +end + +class Prism::PostExecutionNode < ::Prism::Node + sig do + params( + source: Prism::Source, + statements: T.nilable(Prism::StatementsNode), + keyword_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + statements: T.nilable(Prism::StatementsNode), + keyword_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::PostExecutionNode) + end + def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::PreExecutionNode < ::Prism::Node + sig do + params( + source: Prism::Source, + statements: T.nilable(Prism::StatementsNode), + keyword_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + statements: T.nilable(Prism::StatementsNode), + keyword_loc: Prism::Location, + opening_loc: Prism::Location, + closing_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::PreExecutionNode) + end + def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ProgramNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + statements: Prism::StatementsNode, + location: Prism::Location + ).void + end + def initialize(source, locals, statements, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + locals: T::Array[Symbol], + statements: Prism::StatementsNode, + location: Prism::Location + ).returns(Prism::ProgramNode) + end + def copy(locals: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(Prism::StatementsNode) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +# Flags for range and flip-flop nodes. +module Prism::RangeFlags; end + +Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) + +class Prism::RangeNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + left: T.nilable(Prism::Node), + right: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, left, right, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + left: T.nilable(Prism::Node), + right: T.nilable(Prism::Node), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::RangeNode) + end + def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def exclude_end?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Prism::Node)) } + def left; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def right; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::RationalNode < ::Prism::Node + sig { params(source: Prism::Source, numeric: Prism::Node, location: Prism::Location).void } + def initialize(source, numeric, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(numeric: Prism::Node, location: Prism::Location).returns(Prism::RationalNode) } + def copy(numeric: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Prism::Node) } + def numeric; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(Rational) } + def value; end + + class << self + def type; end + end +end + +class Prism::RedoNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::RedoNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +module Prism::Reflection + class << self + sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) } + def fields_for(node); end + end +end + +class Prism::Reflection::ConstantField < ::Prism::Reflection::Field; end +class Prism::Reflection::ConstantListField < ::Prism::Reflection::Field; end + +class Prism::Reflection::Field + sig { params(name: Symbol).void } + def initialize(name); end + + sig { returns(Symbol) } + def name; end +end + +class Prism::Reflection::FlagsField < ::Prism::Reflection::Field + sig { params(name: Symbol, flags: T::Array[Symbol]).void } + def initialize(name, flags); end + + sig { returns(T::Array[Symbol]) } + def flags; end +end + +class Prism::Reflection::FloatField < ::Prism::Reflection::Field; end +class Prism::Reflection::IntegerField < ::Prism::Reflection::Field; end +class Prism::Reflection::LocationField < ::Prism::Reflection::Field; end +class Prism::Reflection::NodeField < ::Prism::Reflection::Field; end +class Prism::Reflection::NodeListField < ::Prism::Reflection::Field; end +class Prism::Reflection::OptionalConstantField < ::Prism::Reflection::Field; end +class Prism::Reflection::OptionalLocationField < ::Prism::Reflection::Field; end +class Prism::Reflection::OptionalNodeField < ::Prism::Reflection::Field; end +class Prism::Reflection::StringField < ::Prism::Reflection::Field; end + +# Flags for regular expression and match last line nodes. +module Prism::RegularExpressionFlags; end + +Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer) +Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) + +class Prism::RegularExpressionNode < ::Prism::Node + include ::Prism::RegularExpressionOptions + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def ascii_8bit?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(String) } + def content; end + + sig { returns(Prism::Location) } + def content_loc; end + + sig do + params( + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).returns(Prism::RegularExpressionNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def euc_jp?; end + + sig { returns(T::Boolean) } + def extended?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_us_ascii_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def ignore_case?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def multi_line?; end + + sig { returns(T::Boolean) } + def once?; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Integer) } + def options; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(String) } + def unescaped; end + + sig { returns(T::Boolean) } + def utf_8?; end + + sig { returns(T::Boolean) } + def windows_31j?; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +module Prism::RegularExpressionOptions + def options; end +end + +class Prism::RequiredKeywordParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: Symbol, + name_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::RequiredKeywordParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(Prism::Location) } + def name_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::RequiredParameterNode < ::Prism::Node + sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void } + def initialize(source, flags, name, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) } + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(Symbol) } + def name; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::RescueModifierNode < ::Prism::Node + sig do + params( + source: Prism::Source, + expression: Prism::Node, + keyword_loc: Prism::Location, + rescue_expression: Prism::Node, + location: Prism::Location + ).void + end + def initialize(source, expression, keyword_loc, rescue_expression, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + expression: Prism::Node, + keyword_loc: Prism::Location, + rescue_expression: Prism::Node, + location: Prism::Location + ).returns(Prism::RescueModifierNode) + end + def copy(expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Prism::Node) } + def expression; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def rescue_expression; end + + def set_newline_flag(newline_marked); end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::RescueNode < ::Prism::Node + sig do + params( + source: Prism::Source, + keyword_loc: Prism::Location, + exceptions: T::Array[Prism::Node], + operator_loc: T.nilable(Prism::Location), + reference: T.nilable(Prism::Node), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::RescueNode), + location: Prism::Location + ).void + end + def initialize(source, keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::RescueNode)) } + def consequent; end + + sig do + params( + keyword_loc: Prism::Location, + exceptions: T::Array[Prism::Node], + operator_loc: T.nilable(Prism::Location), + reference: T.nilable(Prism::Node), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::RescueNode), + location: Prism::Location + ).returns(Prism::RescueNode) + end + def copy(keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Array[Prism::Node]) } + def exceptions; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T.nilable(String)) } + def operator; end + + sig { returns(T.nilable(Prism::Location)) } + def operator_loc; end + + sig { returns(T.nilable(Prism::Node)) } + def reference; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::RestParameterNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, flags, name, name_loc, operator_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + name: T.nilable(Symbol), + name_loc: T.nilable(Prism::Location), + operator_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::RestParameterNode) + end + def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(Symbol)) } + def name; end + + sig { returns(T.nilable(Prism::Location)) } + def name_loc; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { returns(T::Boolean) } + def repeated_parameter?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::Result + sig do + params( + comments: T::Array[Prism::Comment], + magic_comments: T::Array[Prism::MagicComment], + data_loc: T.nilable(Prism::Location), + errors: T::Array[Prism::ParseError], + warnings: T::Array[Prism::ParseWarning], + source: Prism::Source + ).void + end + def initialize(comments, magic_comments, data_loc, errors, warnings, source); end + + sig { returns(T::Array[Prism::Comment]) } + def comments; end + + sig { returns(T.nilable(Prism::Location)) } + def data_loc; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Encoding) } + def encoding; end + + sig { returns(T::Array[Prism::ParseError]) } + def errors; end + + sig { returns(T::Boolean) } + def failure?; end + + sig { returns(T::Array[Prism::MagicComment]) } + def magic_comments; end + + sig { returns(Prism::Source) } + def source; end + + sig { returns(T::Boolean) } + def success?; end + + sig { returns(T::Array[Prism::ParseWarning]) } + def warnings; end +end + +class Prism::RetryNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::RetryNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::ReturnNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + keyword_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + location: Prism::Location + ).void + end + def initialize(source, flags, keyword_loc, arguments, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + keyword_loc: Prism::Location, + arguments: T.nilable(Prism::ArgumentsNode), + location: Prism::Location + ).returns(Prism::ReturnNode) + end + def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T::Boolean) } + def redundant?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for return nodes. +module Prism::ReturnNodeFlags; end + +Prism::ReturnNodeFlags::REDUNDANT = T.let(T.unsafe(nil), Integer) + +class Prism::SelfNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::SelfNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +module Prism::Serialize + class << self + def load(input, serialized); end + def load_tokens(source, serialized); end + end +end + +class Prism::Serialize::Loader + def initialize(source, serialized); end + + def constant_pool; end + def constant_pool_offset; end + def encoding; end + def input; end + def io; end + def load_comments; end + def load_encoding; end + def load_header; end + def load_line_offsets; end + def load_metadata; end + def load_nodes; end + def load_result; end + def load_start_line; end + def load_tokens; end + def load_tokens_result; end + def serialized; end + def source; end + def start_line; end + + private + + def load_constant(index); end + def load_double; end + def load_embedded_string; end + def load_error_level; end + def load_integer; end + def load_location; end + def load_location_object; end + def load_node; end + def load_optional_constant; end + def load_optional_location; end + def load_optional_location_object; end + def load_optional_node; end + def load_required_constant; end + def load_string; end + def load_uint32; end + def load_varsint; end + def load_varuint; end + def load_warning_level; end +end + +Prism::Serialize::Loader::DIAGNOSTIC_TYPES = T.let(T.unsafe(nil), Array) +Prism::Serialize::Loader::FastStringIO = StringIO +Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer) +Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer) +Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer) +Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +class Prism::ShareableConstantNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode), + location: Prism::Location + ).void + end + def initialize(source, flags, write, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode), + location: Prism::Location + ).returns(Prism::ShareableConstantNode) + end + def copy(flags: T.unsafe(nil), write: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T::Boolean) } + def experimental_copy?; end + + sig { returns(T::Boolean) } + def experimental_everything?; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def literal?; end + + sig { override.returns(Symbol) } + def type; end + + sig do + returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)) + end + def write; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +# Flags for shareable constant nodes. +module Prism::ShareableConstantNodeFlags; end + +Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer) +Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer) +Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer) + +class Prism::SingletonClassNode < ::Prism::Node + sig do + params( + source: Prism::Source, + locals: T::Array[Symbol], + class_keyword_loc: Prism::Location, + operator_loc: Prism::Location, + expression: Prism::Node, + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::Node)) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def class_keyword; end + + sig { returns(Prism::Location) } + def class_keyword_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + locals: T::Array[Symbol], + class_keyword_loc: Prism::Location, + operator_loc: Prism::Location, + expression: Prism::Node, + body: T.nilable(Prism::Node), + end_keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::SingletonClassNode) + end + def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(String) } + def end_keyword; end + + sig { returns(Prism::Location) } + def end_keyword_loc; end + + sig { returns(Prism::Node) } + def expression; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Array[Symbol]) } + def locals; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::Source + sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void } + def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end + + sig { params(byte_offset: Integer).returns(Integer) } + def character_column(byte_offset); end + + sig { params(byte_offset: Integer).returns(Integer) } + def character_offset(byte_offset); end + + sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } + def code_units_column(byte_offset, encoding); end + + sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } + def code_units_offset(byte_offset, encoding); end + + sig { params(byte_offset: Integer).returns(Integer) } + def column(byte_offset); end + + sig { returns(Encoding) } + def encoding; end + + sig { params(byte_offset: Integer).returns(Integer) } + def line(byte_offset); end + + def line_end(byte_offset); end + + sig { params(byte_offset: Integer).returns(Integer) } + def line_start(byte_offset); end + + sig { returns(T::Array[String]) } + def lines; end + + sig { returns(T::Array[Integer]) } + def offsets; end + + sig { params(byte_offset: Integer, length: Integer).returns(String) } + def slice(byte_offset, length); end + + sig { returns(String) } + def source; end + + sig { returns(Integer) } + def start_line; end + + private + + def find_line(byte_offset); end + + class << self + def for(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end + end +end + +class Prism::SourceEncodingNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::SourceEncodingNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::SourceFileNode < ::Prism::Node + sig { params(source: Prism::Source, flags: Integer, filepath: String, location: Prism::Location).void } + def initialize(source, flags, filepath, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(flags: Integer, filepath: String, location: Prism::Location).returns(Prism::SourceFileNode) } + def copy(flags: T.unsafe(nil), filepath: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(String) } + def filepath; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def frozen?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def mutable?; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::SourceLineNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::SourceLineNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::SplatNode < ::Prism::Node + sig do + params( + source: Prism::Source, + operator_loc: Prism::Location, + expression: T.nilable(Prism::Node), + location: Prism::Location + ).void + end + def initialize(source, operator_loc, expression, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + operator_loc: Prism::Location, + expression: T.nilable(Prism::Node), + location: Prism::Location + ).returns(Prism::SplatNode) + end + def copy(operator_loc: T.unsafe(nil), expression: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(Prism::Node)) } + def expression; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def operator; end + + sig { returns(Prism::Location) } + def operator_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::StatementsNode < ::Prism::Node + sig { params(source: Prism::Source, body: T::Array[Prism::Node], location: Prism::Location).void } + def initialize(source, body, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Array[Prism::Node]) } + def body; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) } + def copy(body: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +# Flags for string nodes. +module Prism::StringFlags; end + +Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer) +Prism::StringFlags::MUTABLE = T.let(T.unsafe(nil), Integer) + +class Prism::StringNode < ::Prism::Node + include ::Prism::HeredocQuery + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: T.nilable(Prism::Location), + content_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + unescaped: String, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(String) } + def content; end + + sig { returns(Prism::Location) } + def content_loc; end + + sig do + params( + flags: Integer, + opening_loc: T.nilable(Prism::Location), + content_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + unescaped: String, + location: Prism::Location + ).returns(Prism::StringNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def frozen?; end + + sig { returns(T::Boolean) } + def heredoc?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T::Boolean) } + def mutable?; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { returns(Prism::InterpolatedStringNode) } + def to_interpolated; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(String) } + def unescaped; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::SuperNode < ::Prism::Node + sig do + params( + source: Prism::Source, + keyword_loc: Prism::Location, + lparen_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + rparen_loc: T.nilable(Prism::Location), + block: T.nilable(Prism::Node), + location: Prism::Location + ).void + end + def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { returns(T.nilable(Prism::Node)) } + def block; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + keyword_loc: Prism::Location, + lparen_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + rparen_loc: T.nilable(Prism::Location), + block: T.nilable(Prism::Node), + location: Prism::Location + ).returns(Prism::SuperNode) + end + def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +# Flags for symbol nodes. +module Prism::SymbolFlags; end + +Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) +Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) + +class Prism::SymbolNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: T.nilable(Prism::Location), + value_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + unescaped: String, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, value_loc, closing_loc, unescaped, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + opening_loc: T.nilable(Prism::Location), + value_loc: T.nilable(Prism::Location), + closing_loc: T.nilable(Prism::Location), + unescaped: String, + location: Prism::Location + ).returns(Prism::SymbolNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_us_ascii_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(T.nilable(String)) } + def opening; end + + sig { returns(T.nilable(Prism::Location)) } + def opening_loc; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(String) } + def unescaped; end + + sig { returns(T.nilable(String)) } + def value; end + + sig { returns(T.nilable(Prism::Location)) } + def value_loc; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::Token + sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void } + def initialize(source, type, value, location); end + + sig { params(other: T.untyped).returns(T::Boolean) } + def ==(other); end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(Prism::Location) } + def location; end + + sig { params(q: T.untyped).void } + def pretty_print(q); end + + sig { returns(Symbol) } + def type; end + + sig { returns(String) } + def value; end + + private + + sig { returns(Prism::Source) } + def source; end +end + +module Prism::Translation; end + +class Prism::Translation::Parser < ::Parser::Base + def default_encoding; end + def parse(source_buffer); end + def parse_with_comments(source_buffer); end + def tokenize(source_buffer, recover = T.unsafe(nil)); end + def try_declare_numparam(node); end + + sig { overridable.returns(Integer) } + def version; end + + def yyerror; end + + private + + def build_ast(program, offset_cache); end + def build_comments(comments, offset_cache); end + def build_offset_cache(source); end + def build_range(location, offset_cache); end + def build_tokens(tokens, offset_cache); end + def convert_for_prism(version); end + def error_diagnostic(error, offset_cache); end + def unwrap(result, offset_cache); end + def valid_error?(error); end + def valid_warning?(warning); end + def warning_diagnostic(warning, offset_cache); end +end + +class Prism::Translation::Parser33 < ::Prism::Translation::Parser + sig { override.returns(Integer) } + def version; end +end + +class Prism::Translation::Parser34 < ::Prism::Translation::Parser + sig { override.returns(Integer) } + def version; end +end + +class Prism::Translation::Parser::Compiler < ::Prism::Compiler + def initialize(parser, offset_cache, forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end + + def builder; end + def forwarding; end + def in_destructure; end + def in_pattern; end + def offset_cache; end + def parser; end + def source_buffer; end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end + + private + + def copy_compiler(forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end + def find_forwarding(node); end + def imaginary_value(node); end + def numeric_negate(message_loc, receiver); end + def procarg0?(parameters); end + def rational_value(node); end + def srange(location); end + def srange_find(start_offset, end_offset, tokens); end + def srange_offsets(start_offset, end_offset); end + def token(location); end + def visit_block(call, block); end + def visit_heredoc(node); end + def visit_numeric(node, value); end + def within_pattern; end +end + +class Prism::Translation::Parser::Compiler::CompilationError < ::StandardError; end +Prism::Translation::Parser::Compiler::Range = Parser::Source::Range +Prism::Translation::Parser::Diagnostic = Parser::Diagnostic + +class Prism::Translation::Parser::Lexer + def initialize(source_buffer, lexed, offset_cache); end + + def lexed; end + def offset_cache; end + def source_buffer; end + def to_a; end + + private + + def parse_complex(value); end + def parse_float(value); end + def parse_integer(value); end + def parse_rational(value); end +end + +Prism::Translation::Parser::Lexer::EXPR_BEG = T.let(T.unsafe(nil), Integer) +Prism::Translation::Parser::Lexer::EXPR_LABEL = T.let(T.unsafe(nil), Integer) +Prism::Translation::Parser::Lexer::Range = Parser::Source::Range +Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash) + +class Prism::Translation::Parser::PrismDiagnostic < ::Parser::Diagnostic + def initialize(message, level, reason, location); end + + def message; end +end + +Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass) + +class Prism::Translation::Ripper < ::Prism::Compiler + def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end + + def column; end + + sig { returns(T::Boolean) } + def error?; end + + def filename; end + def lineno; end + + sig { returns(T.untyped) } + def parse; end + + def source; end + def visit_alias_global_variable_node(node); end + def visit_alias_method_node(node); end + def visit_alternation_pattern_node(node); end + def visit_and_node(node); end + def visit_arguments_node(node); end + def visit_array_node(node); end + def visit_array_pattern_node(node); end + def visit_assoc_node(node); end + def visit_assoc_splat_node(node); end + def visit_back_reference_read_node(node); end + def visit_begin_node(node); end + def visit_block_argument_node(node); end + def visit_block_local_variable_node(node); end + def visit_block_node(node); end + def visit_block_parameter_node(node); end + def visit_block_parameters_node(node); end + def visit_break_node(node); end + def visit_call_and_write_node(node); end + def visit_call_node(node); end + def visit_call_operator_write_node(node); end + def visit_call_or_write_node(node); end + def visit_call_target_node(node); end + def visit_capture_pattern_node(node); end + def visit_case_match_node(node); end + def visit_case_node(node); end + def visit_class_node(node); end + def visit_class_variable_and_write_node(node); end + def visit_class_variable_operator_write_node(node); end + def visit_class_variable_or_write_node(node); end + def visit_class_variable_read_node(node); end + def visit_class_variable_target_node(node); end + def visit_class_variable_write_node(node); end + def visit_constant_and_write_node(node); end + def visit_constant_operator_write_node(node); end + def visit_constant_or_write_node(node); end + def visit_constant_path_and_write_node(node); end + def visit_constant_path_node(node); end + def visit_constant_path_operator_write_node(node); end + def visit_constant_path_or_write_node(node); end + def visit_constant_path_target_node(node); end + def visit_constant_path_write_node(node); end + def visit_constant_read_node(node); end + def visit_constant_target_node(node); end + def visit_constant_write_node(node); end + def visit_def_node(node); end + def visit_defined_node(node); end + def visit_else_node(node); end + def visit_embedded_statements_node(node); end + def visit_embedded_variable_node(node); end + def visit_ensure_node(node); end + def visit_false_node(node); end + def visit_find_pattern_node(node); end + def visit_flip_flop_node(node); end + def visit_float_node(node); end + def visit_for_node(node); end + def visit_forwarding_arguments_node(node); end + def visit_forwarding_parameter_node(node); end + def visit_forwarding_super_node(node); end + def visit_global_variable_and_write_node(node); end + def visit_global_variable_operator_write_node(node); end + def visit_global_variable_or_write_node(node); end + def visit_global_variable_read_node(node); end + def visit_global_variable_target_node(node); end + def visit_global_variable_write_node(node); end + def visit_hash_node(node); end + def visit_hash_pattern_node(node); end + def visit_if_node(node); end + def visit_imaginary_node(node); end + def visit_implicit_node(node); end + def visit_implicit_rest_node(node); end + def visit_in_node(node); end + def visit_index_and_write_node(node); end + def visit_index_operator_write_node(node); end + def visit_index_or_write_node(node); end + def visit_index_target_node(node); end + def visit_instance_variable_and_write_node(node); end + def visit_instance_variable_operator_write_node(node); end + def visit_instance_variable_or_write_node(node); end + def visit_instance_variable_read_node(node); end + def visit_instance_variable_target_node(node); end + def visit_instance_variable_write_node(node); end + def visit_integer_node(node); end + def visit_interpolated_match_last_line_node(node); end + def visit_interpolated_regular_expression_node(node); end + def visit_interpolated_string_node(node); end + def visit_interpolated_symbol_node(node); end + def visit_interpolated_x_string_node(node); end + def visit_it_parameters_node(node); end + def visit_keyword_hash_node(node); end + def visit_keyword_rest_parameter_node(node); end + def visit_lambda_node(node); end + def visit_local_variable_and_write_node(node); end + def visit_local_variable_operator_write_node(node); end + def visit_local_variable_or_write_node(node); end + def visit_local_variable_read_node(node); end + def visit_local_variable_target_node(node); end + def visit_local_variable_write_node(node); end + def visit_match_last_line_node(node); end + def visit_match_predicate_node(node); end + def visit_match_required_node(node); end + def visit_match_write_node(node); end + def visit_missing_node(node); end + def visit_module_node(node); end + def visit_multi_target_node(node); end + def visit_multi_write_node(node); end + def visit_next_node(node); end + def visit_nil_node(node); end + def visit_no_keywords_parameter_node(node); end + def visit_numbered_parameters_node(node); end + def visit_numbered_reference_read_node(node); end + def visit_optional_keyword_parameter_node(node); end + def visit_optional_parameter_node(node); end + def visit_or_node(node); end + def visit_parameters_node(node); end + def visit_parentheses_node(node); end + def visit_pinned_expression_node(node); end + def visit_pinned_variable_node(node); end + def visit_post_execution_node(node); end + def visit_pre_execution_node(node); end + def visit_program_node(node); end + def visit_range_node(node); end + def visit_rational_node(node); end + def visit_redo_node(node); end + def visit_regular_expression_node(node); end + def visit_required_keyword_parameter_node(node); end + def visit_required_parameter_node(node); end + def visit_rescue_modifier_node(node); end + def visit_rescue_node(node); end + def visit_rest_parameter_node(node); end + def visit_retry_node(node); end + def visit_return_node(node); end + def visit_self_node(node); end + def visit_shareable_constant_node(node); end + def visit_singleton_class_node(node); end + def visit_source_encoding_node(node); end + def visit_source_file_node(node); end + def visit_source_line_node(node); end + def visit_splat_node(node); end + def visit_statements_node(node); end + def visit_string_node(node); end + def visit_super_node(node); end + def visit_symbol_node(node); end + def visit_true_node(node); end + def visit_undef_node(node); end + def visit_unless_node(node); end + def visit_until_node(node); end + def visit_when_node(node); end + def visit_while_node(node); end + def visit_x_string_node(node); end + def visit_yield_node(node); end + + private + + def _dispatch_0; end + def _dispatch_1(_); end + def _dispatch_2(_, _); end + def _dispatch_3(_, _, _); end + def _dispatch_4(_, _, _, _); end + def _dispatch_5(_, _, _, _, _); end + def _dispatch_7(_, _, _, _, _, _, _); end + def bounds(location); end + def command?(node); end + def compile_error(msg); end + def dedent_string(string, width); end + def on_BEGIN(_); end + def on_CHAR(_); end + def on_END(_); end + def on___end__(_); end + def on_alias(_, _); end + def on_alias_error(_, _); end + def on_aref(_, _); end + def on_aref_field(_, _); end + def on_arg_ambiguous(_); end + def on_arg_paren(_); end + def on_args_add(_, _); end + def on_args_add_block(_, _); end + def on_args_add_star(_, _); end + def on_args_forward; end + def on_args_new; end + def on_array(_); end + def on_aryptn(_, _, _, _); end + def on_assign(_, _); end + def on_assign_error(_, _); end + def on_assoc_new(_, _); end + def on_assoc_splat(_); end + def on_assoclist_from_args(_); end + def on_backref(_); end + def on_backtick(_); end + def on_bare_assoc_hash(_); end + def on_begin(_); end + def on_binary(_, _, _); end + def on_block_var(_, _); end + def on_blockarg(_); end + def on_bodystmt(_, _, _, _); end + def on_brace_block(_, _); end + def on_break(_); end + def on_call(_, _, _); end + def on_case(_, _); end + def on_class(_, _, _); end + def on_class_name_error(_, _); end + def on_comma(_); end + def on_command(_, _); end + def on_command_call(_, _, _, _); end + def on_comment(_); end + def on_const(_); end + def on_const_path_field(_, _); end + def on_const_path_ref(_, _); end + def on_const_ref(_); end + def on_cvar(_); end + def on_def(_, _, _); end + def on_defined(_); end + def on_defs(_, _, _, _, _); end + def on_do_block(_, _); end + def on_dot2(_, _); end + def on_dot3(_, _); end + def on_dyna_symbol(_); end + def on_else(_); end + def on_elsif(_, _, _); end + def on_embdoc(_); end + def on_embdoc_beg(_); end + def on_embdoc_end(_); end + def on_embexpr_beg(_); end + def on_embexpr_end(_); end + def on_embvar(_); end + def on_ensure(_); end + def on_excessed_comma; end + def on_fcall(_); end + def on_field(_, _, _); end + def on_float(_); end + def on_fndptn(_, _, _, _); end + def on_for(_, _, _); end + def on_gvar(_); end + def on_hash(_); end + def on_heredoc_beg(_); end + def on_heredoc_dedent(_, _); end + def on_heredoc_end(_); end + def on_hshptn(_, _, _); end + def on_ident(_); end + def on_if(_, _, _); end + def on_if_mod(_, _); end + def on_ifop(_, _, _); end + def on_ignored_nl(_); end + def on_ignored_sp(_); end + def on_imaginary(_); end + def on_in(_, _, _); end + def on_int(_); end + def on_ivar(_); end + def on_kw(_); end + def on_kwrest_param(_); end + def on_label(_); end + def on_label_end(_); end + def on_lambda(_, _); end + def on_lbrace(_); end + def on_lbracket(_); end + def on_lparen(_); end + def on_magic_comment(_, _); end + def on_massign(_, _); end + def on_method_add_arg(_, _); end + def on_method_add_block(_, _); end + def on_mlhs_add(_, _); end + def on_mlhs_add_post(_, _); end + def on_mlhs_add_star(_, _); end + def on_mlhs_new; end + def on_mlhs_paren(_); end + def on_module(_, _); end + def on_mrhs_add(_, _); end + def on_mrhs_add_star(_, _); end + def on_mrhs_new; end + def on_mrhs_new_from_args(_); end + def on_next(_); end + def on_nl(_); end + def on_nokw_param(_); end + def on_op(_); end + def on_opassign(_, _, _); end + def on_operator_ambiguous(_, _); end + def on_param_error(_, _); end + def on_params(_, _, _, _, _, _, _); end + def on_paren(_); end + def on_parse_error(_); end + def on_period(_); end + def on_program(_); end + def on_qsymbols_add(_, _); end + def on_qsymbols_beg(_); end + def on_qsymbols_new; end + def on_qwords_add(_, _); end + def on_qwords_beg(_); end + def on_qwords_new; end + def on_rational(_); end + def on_rbrace(_); end + def on_rbracket(_); end + def on_redo; end + def on_regexp_add(_, _); end + def on_regexp_beg(_); end + def on_regexp_end(_); end + def on_regexp_literal(_, _); end + def on_regexp_new; end + def on_rescue(_, _, _, _); end + def on_rescue_mod(_, _); end + def on_rest_param(_); end + def on_retry; end + def on_return(_); end + def on_return0; end + def on_rparen(_); end + def on_sclass(_, _); end + def on_semicolon(_); end + def on_sp(_); end + def on_stmts_add(_, _); end + def on_stmts_new; end + def on_string_add(_, _); end + def on_string_concat(_, _); end + def on_string_content; end + def on_string_dvar(_); end + def on_string_embexpr(_); end + def on_string_literal(_); end + def on_super(_); end + def on_symbeg(_); end + def on_symbol(_); end + def on_symbol_literal(_); end + def on_symbols_add(_, _); end + def on_symbols_beg(_); end + def on_symbols_new; end + def on_tlambda(_); end + def on_tlambeg(_); end + def on_top_const_field(_); end + def on_top_const_ref(_); end + def on_tstring_beg(_); end + def on_tstring_content(_); end + def on_tstring_end(_); end + def on_unary(_, _); end + def on_undef(_); end + def on_unless(_, _, _); end + def on_unless_mod(_, _); end + def on_until(_, _); end + def on_until_mod(_, _); end + def on_var_alias(_, _); end + def on_var_field(_); end + def on_var_ref(_); end + def on_vcall(_); end + def on_void_stmt; end + def on_when(_, _, _); end + def on_while(_, _); end + def on_while_mod(_, _); end + def on_word_add(_, _); end + def on_word_new; end + def on_words_add(_, _); end + def on_words_beg(_); end + def on_words_new; end + def on_words_sep(_); end + def on_xstring_add(_, _); end + def on_xstring_literal(_); end + def on_xstring_new; end + def on_yield(_); end + def on_yield0; end + def on_zsuper; end + def result; end + def trailing_comma?(left, right); end + def visit_alias_global_variable_node_value(node); end + def visit_arguments(elements); end + def visit_begin_node_clauses(location, node, allow_newline); end + def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end + def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end + def visit_constant_path_write_node_target(node); end + def visit_destructured_parameter_node(node); end + def visit_heredoc_node(parts, base); end + def visit_heredoc_node_whitespace(parts); end + def visit_heredoc_string_node(node); end + def visit_heredoc_x_string_node(node); end + def visit_multi_target_node_targets(lefts, rest, rights, skippable); end + def visit_number_node(node); end + def visit_pattern_node(node); end + def visit_statements_node_body(body); end + def visit_string_content(part); end + def visit_token(token, allow_keywords = T.unsafe(nil)); end + def visit_words_sep(opening_loc, previous, current); end + def visit_write_value(node); end + def void_stmt?(left, right, allow_newline); end + def warn(fmt, *args); end + def warning(fmt, *args); end + + class << self + def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end + def parse(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end + def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end + def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end + end +end + +Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) +Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array) +Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array) +Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array) +Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash) +Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array) +Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash) + +class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper + def error; end + def on_BEGIN(*args); end + def on_CHAR(tok); end + def on_END(*args); end + def on___end__(tok); end + def on_alias(*args); end + def on_alias_error(*args); end + def on_aref(*args); end + def on_aref_field(*args); end + def on_arg_ambiguous(*args); end + def on_arg_paren(*args); end + def on_args_add(*args); end + def on_args_add_block(*args); end + def on_args_add_star(*args); end + def on_args_forward(*args); end + def on_args_new(*args); end + def on_array(*args); end + def on_aryptn(*args); end + def on_assign(*args); end + def on_assign_error(*args); end + def on_assoc_new(*args); end + def on_assoc_splat(*args); end + def on_assoclist_from_args(*args); end + def on_backref(tok); end + def on_backtick(tok); end + def on_bare_assoc_hash(*args); end + def on_begin(*args); end + def on_binary(*args); end + def on_block_var(*args); end + def on_blockarg(*args); end + def on_bodystmt(*args); end + def on_brace_block(*args); end + def on_break(*args); end + def on_call(*args); end + def on_case(*args); end + def on_class(*args); end + def on_class_name_error(*args); end + def on_comma(tok); end + def on_command(*args); end + def on_command_call(*args); end + def on_comment(tok); end + def on_const(tok); end + def on_const_path_field(*args); end + def on_const_path_ref(*args); end + def on_const_ref(*args); end + def on_cvar(tok); end + def on_def(*args); end + def on_defined(*args); end + def on_defs(*args); end + def on_do_block(*args); end + def on_dot2(*args); end + def on_dot3(*args); end + def on_dyna_symbol(*args); end + def on_else(*args); end + def on_elsif(*args); end + def on_embdoc(tok); end + def on_embdoc_beg(tok); end + def on_embdoc_end(tok); end + def on_embexpr_beg(tok); end + def on_embexpr_end(tok); end + def on_embvar(tok); end + def on_ensure(*args); end + def on_excessed_comma(*args); end + def on_fcall(*args); end + def on_field(*args); end + def on_float(tok); end + def on_fndptn(*args); end + def on_for(*args); end + def on_gvar(tok); end + def on_hash(*args); end + def on_heredoc_beg(tok); end + def on_heredoc_end(tok); end + def on_hshptn(*args); end + def on_ident(tok); end + def on_if(*args); end + def on_if_mod(*args); end + def on_ifop(*args); end + def on_ignored_nl(tok); end + def on_ignored_sp(tok); end + def on_imaginary(tok); end + def on_in(*args); end + def on_int(tok); end + def on_ivar(tok); end + def on_kw(tok); end + def on_kwrest_param(*args); end + def on_label(tok); end + def on_label_end(tok); end + def on_lambda(*args); end + def on_lbrace(tok); end + def on_lbracket(tok); end + def on_lparen(tok); end + def on_magic_comment(*args); end + def on_massign(*args); end + def on_method_add_arg(*args); end + def on_method_add_block(*args); end + def on_mlhs_add(*args); end + def on_mlhs_add_post(*args); end + def on_mlhs_add_star(*args); end + def on_mlhs_new(*args); end + def on_mlhs_paren(*args); end + def on_module(*args); end + def on_mrhs_add(*args); end + def on_mrhs_add_star(*args); end + def on_mrhs_new(*args); end + def on_mrhs_new_from_args(*args); end + def on_next(*args); end + def on_nl(tok); end + def on_nokw_param(*args); end + def on_op(tok); end + def on_opassign(*args); end + def on_operator_ambiguous(*args); end + def on_param_error(*args); end + def on_params(*args); end + def on_paren(*args); end + def on_period(tok); end + def on_program(*args); end + def on_qsymbols_add(*args); end + def on_qsymbols_beg(tok); end + def on_qsymbols_new(*args); end + def on_qwords_add(*args); end + def on_qwords_beg(tok); end + def on_qwords_new(*args); end + def on_rational(tok); end + def on_rbrace(tok); end + def on_rbracket(tok); end + def on_redo(*args); end + def on_regexp_add(*args); end + def on_regexp_beg(tok); end + def on_regexp_end(tok); end + def on_regexp_literal(*args); end + def on_regexp_new(*args); end + def on_rescue(*args); end + def on_rescue_mod(*args); end + def on_rest_param(*args); end + def on_retry(*args); end + def on_return(*args); end + def on_return0(*args); end + def on_rparen(tok); end + def on_sclass(*args); end + def on_semicolon(tok); end + def on_sp(tok); end + def on_stmts_add(*args); end + def on_stmts_new(*args); end + def on_string_add(*args); end + def on_string_concat(*args); end + def on_string_content(*args); end + def on_string_dvar(*args); end + def on_string_embexpr(*args); end + def on_string_literal(*args); end + def on_super(*args); end + def on_symbeg(tok); end + def on_symbol(*args); end + def on_symbol_literal(*args); end + def on_symbols_add(*args); end + def on_symbols_beg(tok); end + def on_symbols_new(*args); end + def on_tlambda(tok); end + def on_tlambeg(tok); end + def on_top_const_field(*args); end + def on_top_const_ref(*args); end + def on_tstring_beg(tok); end + def on_tstring_content(tok); end + def on_tstring_end(tok); end + def on_unary(*args); end + def on_undef(*args); end + def on_unless(*args); end + def on_unless_mod(*args); end + def on_until(*args); end + def on_until_mod(*args); end + def on_var_alias(*args); end + def on_var_field(*args); end + def on_var_ref(*args); end + def on_vcall(*args); end + def on_void_stmt(*args); end + def on_when(*args); end + def on_while(*args); end + def on_while_mod(*args); end + def on_word_add(*args); end + def on_word_new(*args); end + def on_words_add(*args); end + def on_words_beg(tok); end + def on_words_new(*args); end + def on_words_sep(tok); end + def on_xstring_add(*args); end + def on_xstring_literal(*args); end + def on_xstring_new(*args); end + def on_yield(*args); end + def on_yield0(*args); end + def on_zsuper(*args); end + + private + + def compile_error(mesg); end + def dedent_element(e, width); end + def on_error(mesg); end + def on_heredoc_dedent(val, width); end + def on_parse_error(mesg); end +end + +class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder + private + + def _dispatch_event_new; end + def _dispatch_event_push(list, item); end + def on_args_add(list, item); end + def on_args_new; end + def on_heredoc_dedent(val, width); end + def on_mlhs_add(list, item); end + def on_mlhs_add_post(list, post); end + def on_mlhs_add_star(list, star); end + def on_mlhs_new; end + def on_mlhs_paren(list); end + def on_mrhs_add(list, item); end + def on_mrhs_new; end + def on_qsymbols_add(list, item); end + def on_qsymbols_new; end + def on_qwords_add(list, item); end + def on_qwords_new; end + def on_regexp_add(list, item); end + def on_regexp_new; end + def on_stmts_add(list, item); end + def on_stmts_new; end + def on_string_add(list, item); end + def on_symbols_add(list, item); end + def on_symbols_new; end + def on_word_add(list, item); end + def on_word_new; end + def on_words_add(list, item); end + def on_words_new; end + def on_xstring_add(list, item); end + def on_xstring_new; end +end + +class Prism::TrueNode < ::Prism::Node + sig { params(source: Prism::Source, location: Prism::Location).void } + def initialize(source, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { params(location: Prism::Location).returns(Prism::TrueNode) } + def copy(location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::UndefNode < ::Prism::Node + sig do + params( + source: Prism::Source, + names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)], + keyword_loc: Prism::Location, + location: Prism::Location + ).void + end + def initialize(source, names, keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)], + keyword_loc: Prism::Location, + location: Prism::Location + ).returns(Prism::UndefNode) + end + def copy(names: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) } + def names; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::UnlessNode < ::Prism::Node + sig do + params( + source: Prism::Source, + keyword_loc: Prism::Location, + predicate: Prism::Node, + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::ElseNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T.nilable(Prism::ElseNode)) } + def consequent; end + + sig do + params( + keyword_loc: Prism::Location, + predicate: Prism::Node, + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + consequent: T.nilable(Prism::ElseNode), + end_keyword_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::UnlessNode) + end + def copy(keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { returns(T.nilable(String)) } + def end_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def end_keyword_loc; end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def predicate; end + + def set_newline_flag(newline_marked); end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { returns(T.nilable(String)) } + def then_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def then_keyword_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::UntilNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + keyword_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).void + end + def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def begin_modifier?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + keyword_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).returns(Prism::UntilNode) + end + def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def predicate; end + + def set_newline_flag(newline_marked); end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +Prism::VERSION = T.let(T.unsafe(nil), String) + +class Prism::Visitor < ::Prism::BasicVisitor + sig { params(node: Prism::AliasGlobalVariableNode).void } + def visit_alias_global_variable_node(node); end + + sig { params(node: Prism::AliasMethodNode).void } + def visit_alias_method_node(node); end + + sig { params(node: Prism::AlternationPatternNode).void } + def visit_alternation_pattern_node(node); end + + sig { params(node: Prism::AndNode).void } + def visit_and_node(node); end + + sig { params(node: Prism::ArgumentsNode).void } + def visit_arguments_node(node); end + + sig { params(node: Prism::ArrayNode).void } + def visit_array_node(node); end + + sig { params(node: Prism::ArrayPatternNode).void } + def visit_array_pattern_node(node); end + + sig { params(node: Prism::AssocNode).void } + def visit_assoc_node(node); end + + sig { params(node: Prism::AssocSplatNode).void } + def visit_assoc_splat_node(node); end + + sig { params(node: Prism::BackReferenceReadNode).void } + def visit_back_reference_read_node(node); end + + sig { params(node: Prism::BeginNode).void } + def visit_begin_node(node); end + + sig { params(node: Prism::BlockArgumentNode).void } + def visit_block_argument_node(node); end + + sig { params(node: Prism::BlockLocalVariableNode).void } + def visit_block_local_variable_node(node); end + + sig { params(node: Prism::BlockNode).void } + def visit_block_node(node); end + + sig { params(node: Prism::BlockParameterNode).void } + def visit_block_parameter_node(node); end + + sig { params(node: Prism::BlockParametersNode).void } + def visit_block_parameters_node(node); end + + sig { params(node: Prism::BreakNode).void } + def visit_break_node(node); end + + sig { params(node: Prism::CallAndWriteNode).void } + def visit_call_and_write_node(node); end + + sig { params(node: Prism::CallNode).void } + def visit_call_node(node); end + + sig { params(node: Prism::CallOperatorWriteNode).void } + def visit_call_operator_write_node(node); end + + sig { params(node: Prism::CallOrWriteNode).void } + def visit_call_or_write_node(node); end + + sig { params(node: Prism::CallTargetNode).void } + def visit_call_target_node(node); end + + sig { params(node: Prism::CapturePatternNode).void } + def visit_capture_pattern_node(node); end + + sig { params(node: Prism::CaseMatchNode).void } + def visit_case_match_node(node); end + + sig { params(node: Prism::CaseNode).void } + def visit_case_node(node); end + + sig { params(node: Prism::ClassNode).void } + def visit_class_node(node); end + + sig { params(node: Prism::ClassVariableAndWriteNode).void } + def visit_class_variable_and_write_node(node); end + + sig { params(node: Prism::ClassVariableOperatorWriteNode).void } + def visit_class_variable_operator_write_node(node); end + + sig { params(node: Prism::ClassVariableOrWriteNode).void } + def visit_class_variable_or_write_node(node); end + + sig { params(node: Prism::ClassVariableReadNode).void } + def visit_class_variable_read_node(node); end + + sig { params(node: Prism::ClassVariableTargetNode).void } + def visit_class_variable_target_node(node); end + + sig { params(node: Prism::ClassVariableWriteNode).void } + def visit_class_variable_write_node(node); end + + sig { params(node: Prism::ConstantAndWriteNode).void } + def visit_constant_and_write_node(node); end + + sig { params(node: Prism::ConstantOperatorWriteNode).void } + def visit_constant_operator_write_node(node); end + + sig { params(node: Prism::ConstantOrWriteNode).void } + def visit_constant_or_write_node(node); end + + sig { params(node: Prism::ConstantPathAndWriteNode).void } + def visit_constant_path_and_write_node(node); end + + sig { params(node: Prism::ConstantPathNode).void } + def visit_constant_path_node(node); end + + sig { params(node: Prism::ConstantPathOperatorWriteNode).void } + def visit_constant_path_operator_write_node(node); end + + sig { params(node: Prism::ConstantPathOrWriteNode).void } + def visit_constant_path_or_write_node(node); end + + sig { params(node: Prism::ConstantPathTargetNode).void } + def visit_constant_path_target_node(node); end + + sig { params(node: Prism::ConstantPathWriteNode).void } + def visit_constant_path_write_node(node); end + + sig { params(node: Prism::ConstantReadNode).void } + def visit_constant_read_node(node); end + + sig { params(node: Prism::ConstantTargetNode).void } + def visit_constant_target_node(node); end + + sig { params(node: Prism::ConstantWriteNode).void } + def visit_constant_write_node(node); end + + sig { params(node: Prism::DefNode).void } + def visit_def_node(node); end + + sig { params(node: Prism::DefinedNode).void } + def visit_defined_node(node); end + + sig { params(node: Prism::ElseNode).void } + def visit_else_node(node); end + + sig { params(node: Prism::EmbeddedStatementsNode).void } + def visit_embedded_statements_node(node); end + + sig { params(node: Prism::EmbeddedVariableNode).void } + def visit_embedded_variable_node(node); end + + sig { params(node: Prism::EnsureNode).void } + def visit_ensure_node(node); end + + sig { params(node: Prism::FalseNode).void } + def visit_false_node(node); end + + sig { params(node: Prism::FindPatternNode).void } + def visit_find_pattern_node(node); end + + sig { params(node: Prism::FlipFlopNode).void } + def visit_flip_flop_node(node); end + + sig { params(node: Prism::FloatNode).void } + def visit_float_node(node); end + + sig { params(node: Prism::ForNode).void } + def visit_for_node(node); end + + sig { params(node: Prism::ForwardingArgumentsNode).void } + def visit_forwarding_arguments_node(node); end + + sig { params(node: Prism::ForwardingParameterNode).void } + def visit_forwarding_parameter_node(node); end + + sig { params(node: Prism::ForwardingSuperNode).void } + def visit_forwarding_super_node(node); end + + sig { params(node: Prism::GlobalVariableAndWriteNode).void } + def visit_global_variable_and_write_node(node); end + + sig { params(node: Prism::GlobalVariableOperatorWriteNode).void } + def visit_global_variable_operator_write_node(node); end + + sig { params(node: Prism::GlobalVariableOrWriteNode).void } + def visit_global_variable_or_write_node(node); end + + sig { params(node: Prism::GlobalVariableReadNode).void } + def visit_global_variable_read_node(node); end + + sig { params(node: Prism::GlobalVariableTargetNode).void } + def visit_global_variable_target_node(node); end + + sig { params(node: Prism::GlobalVariableWriteNode).void } + def visit_global_variable_write_node(node); end + + sig { params(node: Prism::HashNode).void } + def visit_hash_node(node); end + + sig { params(node: Prism::HashPatternNode).void } + def visit_hash_pattern_node(node); end + + sig { params(node: Prism::IfNode).void } + def visit_if_node(node); end + + sig { params(node: Prism::ImaginaryNode).void } + def visit_imaginary_node(node); end + + sig { params(node: Prism::ImplicitNode).void } + def visit_implicit_node(node); end + + sig { params(node: Prism::ImplicitRestNode).void } + def visit_implicit_rest_node(node); end + + sig { params(node: Prism::InNode).void } + def visit_in_node(node); end + + sig { params(node: Prism::IndexAndWriteNode).void } + def visit_index_and_write_node(node); end + + sig { params(node: Prism::IndexOperatorWriteNode).void } + def visit_index_operator_write_node(node); end + + sig { params(node: Prism::IndexOrWriteNode).void } + def visit_index_or_write_node(node); end + + sig { params(node: Prism::IndexTargetNode).void } + def visit_index_target_node(node); end + + sig { params(node: Prism::InstanceVariableAndWriteNode).void } + def visit_instance_variable_and_write_node(node); end + + sig { params(node: Prism::InstanceVariableOperatorWriteNode).void } + def visit_instance_variable_operator_write_node(node); end + + sig { params(node: Prism::InstanceVariableOrWriteNode).void } + def visit_instance_variable_or_write_node(node); end + + sig { params(node: Prism::InstanceVariableReadNode).void } + def visit_instance_variable_read_node(node); end + + sig { params(node: Prism::InstanceVariableTargetNode).void } + def visit_instance_variable_target_node(node); end + + sig { params(node: Prism::InstanceVariableWriteNode).void } + def visit_instance_variable_write_node(node); end + + sig { params(node: Prism::IntegerNode).void } + def visit_integer_node(node); end + + sig { params(node: Prism::InterpolatedMatchLastLineNode).void } + def visit_interpolated_match_last_line_node(node); end + + sig { params(node: Prism::InterpolatedRegularExpressionNode).void } + def visit_interpolated_regular_expression_node(node); end + + sig { params(node: Prism::InterpolatedStringNode).void } + def visit_interpolated_string_node(node); end + + sig { params(node: Prism::InterpolatedSymbolNode).void } + def visit_interpolated_symbol_node(node); end + + sig { params(node: Prism::InterpolatedXStringNode).void } + def visit_interpolated_x_string_node(node); end + + sig { params(node: Prism::ItParametersNode).void } + def visit_it_parameters_node(node); end + + sig { params(node: Prism::KeywordHashNode).void } + def visit_keyword_hash_node(node); end + + sig { params(node: Prism::KeywordRestParameterNode).void } + def visit_keyword_rest_parameter_node(node); end + + sig { params(node: Prism::LambdaNode).void } + def visit_lambda_node(node); end + + sig { params(node: Prism::LocalVariableAndWriteNode).void } + def visit_local_variable_and_write_node(node); end + + sig { params(node: Prism::LocalVariableOperatorWriteNode).void } + def visit_local_variable_operator_write_node(node); end + + sig { params(node: Prism::LocalVariableOrWriteNode).void } + def visit_local_variable_or_write_node(node); end + + sig { params(node: Prism::LocalVariableReadNode).void } + def visit_local_variable_read_node(node); end + + sig { params(node: Prism::LocalVariableTargetNode).void } + def visit_local_variable_target_node(node); end + + sig { params(node: Prism::LocalVariableWriteNode).void } + def visit_local_variable_write_node(node); end + + sig { params(node: Prism::MatchLastLineNode).void } + def visit_match_last_line_node(node); end + + sig { params(node: Prism::MatchPredicateNode).void } + def visit_match_predicate_node(node); end + + sig { params(node: Prism::MatchRequiredNode).void } + def visit_match_required_node(node); end + + sig { params(node: Prism::MatchWriteNode).void } + def visit_match_write_node(node); end + + sig { params(node: Prism::MissingNode).void } + def visit_missing_node(node); end + + sig { params(node: Prism::ModuleNode).void } + def visit_module_node(node); end + + sig { params(node: Prism::MultiTargetNode).void } + def visit_multi_target_node(node); end + + sig { params(node: Prism::MultiWriteNode).void } + def visit_multi_write_node(node); end + + sig { params(node: Prism::NextNode).void } + def visit_next_node(node); end + + sig { params(node: Prism::NilNode).void } + def visit_nil_node(node); end + + sig { params(node: Prism::NoKeywordsParameterNode).void } + def visit_no_keywords_parameter_node(node); end + + sig { params(node: Prism::NumberedParametersNode).void } + def visit_numbered_parameters_node(node); end + + sig { params(node: Prism::NumberedReferenceReadNode).void } + def visit_numbered_reference_read_node(node); end + + sig { params(node: Prism::OptionalKeywordParameterNode).void } + def visit_optional_keyword_parameter_node(node); end + + sig { params(node: Prism::OptionalParameterNode).void } + def visit_optional_parameter_node(node); end + + sig { params(node: Prism::OrNode).void } + def visit_or_node(node); end + + sig { params(node: Prism::ParametersNode).void } + def visit_parameters_node(node); end + + sig { params(node: Prism::ParenthesesNode).void } + def visit_parentheses_node(node); end + + sig { params(node: Prism::PinnedExpressionNode).void } + def visit_pinned_expression_node(node); end + + sig { params(node: Prism::PinnedVariableNode).void } + def visit_pinned_variable_node(node); end + + sig { params(node: Prism::PostExecutionNode).void } + def visit_post_execution_node(node); end + + sig { params(node: Prism::PreExecutionNode).void } + def visit_pre_execution_node(node); end + + sig { params(node: Prism::ProgramNode).void } + def visit_program_node(node); end + + sig { params(node: Prism::RangeNode).void } + def visit_range_node(node); end + + sig { params(node: Prism::RationalNode).void } + def visit_rational_node(node); end + + sig { params(node: Prism::RedoNode).void } + def visit_redo_node(node); end + + sig { params(node: Prism::RegularExpressionNode).void } + def visit_regular_expression_node(node); end + + sig { params(node: Prism::RequiredKeywordParameterNode).void } + def visit_required_keyword_parameter_node(node); end + + sig { params(node: Prism::RequiredParameterNode).void } + def visit_required_parameter_node(node); end + + sig { params(node: Prism::RescueModifierNode).void } + def visit_rescue_modifier_node(node); end + + sig { params(node: Prism::RescueNode).void } + def visit_rescue_node(node); end + + sig { params(node: Prism::RestParameterNode).void } + def visit_rest_parameter_node(node); end + + sig { params(node: Prism::RetryNode).void } + def visit_retry_node(node); end + + sig { params(node: Prism::ReturnNode).void } + def visit_return_node(node); end + + sig { params(node: Prism::SelfNode).void } + def visit_self_node(node); end + + sig { params(node: Prism::ShareableConstantNode).void } + def visit_shareable_constant_node(node); end + + sig { params(node: Prism::SingletonClassNode).void } + def visit_singleton_class_node(node); end + + sig { params(node: Prism::SourceEncodingNode).void } + def visit_source_encoding_node(node); end + + sig { params(node: Prism::SourceFileNode).void } + def visit_source_file_node(node); end + + sig { params(node: Prism::SourceLineNode).void } + def visit_source_line_node(node); end + + sig { params(node: Prism::SplatNode).void } + def visit_splat_node(node); end + + sig { params(node: Prism::StatementsNode).void } + def visit_statements_node(node); end + + sig { params(node: Prism::StringNode).void } + def visit_string_node(node); end + + sig { params(node: Prism::SuperNode).void } + def visit_super_node(node); end + + sig { params(node: Prism::SymbolNode).void } + def visit_symbol_node(node); end + + sig { params(node: Prism::TrueNode).void } + def visit_true_node(node); end + + sig { params(node: Prism::UndefNode).void } + def visit_undef_node(node); end + + sig { params(node: Prism::UnlessNode).void } + def visit_unless_node(node); end + + sig { params(node: Prism::UntilNode).void } + def visit_until_node(node); end + + sig { params(node: Prism::WhenNode).void } + def visit_when_node(node); end + + sig { params(node: Prism::WhileNode).void } + def visit_while_node(node); end + + sig { params(node: Prism::XStringNode).void } + def visit_x_string_node(node); end + + sig { params(node: Prism::YieldNode).void } + def visit_yield_node(node); end +end + +class Prism::WhenNode < ::Prism::Node + sig do + params( + source: Prism::Source, + keyword_loc: Prism::Location, + conditions: T::Array[Prism::Node], + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).void + end + def initialize(source, keyword_loc, conditions, then_keyword_loc, statements, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(T::Array[Prism::Node]) } + def conditions; end + + sig do + params( + keyword_loc: Prism::Location, + conditions: T::Array[Prism::Node], + then_keyword_loc: T.nilable(Prism::Location), + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).returns(Prism::WhenNode) + end + def copy(keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { returns(T.nilable(String)) } + def then_keyword; end + + sig { returns(T.nilable(Prism::Location)) } + def then_keyword_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end + +class Prism::WhileNode < ::Prism::Node + sig do + params( + source: Prism::Source, + flags: Integer, + keyword_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).void + end + def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T::Boolean) } + def begin_modifier?; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(T.nilable(String)) } + def closing; end + + sig { returns(T.nilable(Prism::Location)) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + flags: Integer, + keyword_loc: Prism::Location, + closing_loc: T.nilable(Prism::Location), + predicate: Prism::Node, + statements: T.nilable(Prism::StatementsNode), + location: Prism::Location + ).returns(Prism::WhileNode) + end + def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(Prism::Node) } + def predicate; end + + def set_newline_flag(newline_marked); end + + sig { returns(T.nilable(Prism::StatementsNode)) } + def statements; end + + sig { override.returns(Symbol) } + def type; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::XStringNode < ::Prism::Node + include ::Prism::HeredocQuery + + sig do + params( + source: Prism::Source, + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).void + end + def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { returns(String) } + def closing; end + + sig { returns(Prism::Location) } + def closing_loc; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig { returns(String) } + def content; end + + sig { returns(Prism::Location) } + def content_loc; end + + sig do + params( + flags: Integer, + opening_loc: Prism::Location, + content_loc: Prism::Location, + closing_loc: Prism::Location, + unescaped: String, + location: Prism::Location + ).returns(Prism::XStringNode) + end + def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { returns(T::Boolean) } + def forced_binary_encoding?; end + + sig { returns(T::Boolean) } + def forced_utf8_encoding?; end + + sig { returns(T::Boolean) } + def heredoc?; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def opening; end + + sig { returns(Prism::Location) } + def opening_loc; end + + sig { returns(Prism::InterpolatedXStringNode) } + def to_interpolated; end + + sig { override.returns(Symbol) } + def type; end + + sig { returns(String) } + def unescaped; end + + protected + + sig { returns(Integer) } + def flags; end + + class << self + def type; end + end +end + +class Prism::YieldNode < ::Prism::Node + sig do + params( + source: Prism::Source, + keyword_loc: Prism::Location, + lparen_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + rparen_loc: T.nilable(Prism::Location), + location: Prism::Location + ).void + end + def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, location); end + + def ===(other); end + + sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } + def accept(visitor); end + + sig { returns(T.nilable(Prism::ArgumentsNode)) } + def arguments; end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def child_nodes; end + + sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } + def comment_targets; end + + sig { override.returns(T::Array[Prism::Node]) } + def compact_child_nodes; end + + sig do + params( + keyword_loc: Prism::Location, + lparen_loc: T.nilable(Prism::Location), + arguments: T.nilable(Prism::ArgumentsNode), + rparen_loc: T.nilable(Prism::Location), + location: Prism::Location + ).returns(Prism::YieldNode) + end + def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end + + sig { override.returns(T::Array[T.nilable(Prism::Node)]) } + def deconstruct; end + + sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + def deconstruct_keys(keys); end + + sig { override.returns(T::Array[Prism::Reflection::Field]) } + def fields; end + + sig { override.returns(String) } + def inspect; end + + sig { returns(String) } + def keyword; end + + sig { returns(Prism::Location) } + def keyword_loc; end + + sig { returns(T.nilable(String)) } + def lparen; end + + sig { returns(T.nilable(Prism::Location)) } + def lparen_loc; end + + sig { returns(T.nilable(String)) } + def rparen; end + + sig { returns(T.nilable(Prism::Location)) } + def rparen_loc; end + + sig { override.returns(Symbol) } + def type; end + + class << self + def type; end + end +end diff --git a/sorbet/rbi/gems/rbi@0.1.10.rbi b/sorbet/rbi/gems/rbi@0.1.13.rbi similarity index 99% rename from sorbet/rbi/gems/rbi@0.1.10.rbi rename to sorbet/rbi/gems/rbi@0.1.13.rbi index a5f771af6..522df9e43 100644 --- a/sorbet/rbi/gems/rbi@0.1.10.rbi +++ b/sorbet/rbi/gems/rbi@0.1.13.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `rbi` gem. # Please instead update this file by running `bin/tapioca gem rbi`. + module RBI; end class RBI::Arg < ::RBI::Node @@ -1964,8 +1965,14 @@ class RBI::Tree < ::RBI::NodeWithComments sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) } def create_path(constant, &block); end - sig { params(parameters: T::Hash[T.any(::String, ::Symbol), ::String], return_type: ::String).returns(::RBI::Sig) } - def create_sig(parameters:, return_type: T.unsafe(nil)); end + sig do + params( + parameters: T::Hash[T.any(::String, ::Symbol), ::String], + type_parameters: T::Array[::String], + return_type: ::String + ).returns(::RBI::Sig) + end + def create_sig(parameters:, type_parameters: T.unsafe(nil), return_type: T.unsafe(nil)); end sig do params( diff --git a/sorbet/rbi/gems/spoom@1.3.0.rbi b/sorbet/rbi/gems/spoom@1.3.2.rbi similarity index 99% rename from sorbet/rbi/gems/spoom@1.3.0.rbi rename to sorbet/rbi/gems/spoom@1.3.2.rbi index db7434e72..e1476f471 100644 --- a/sorbet/rbi/gems/spoom@1.3.0.rbi +++ b/sorbet/rbi/gems/spoom@1.3.2.rbi @@ -4,6 +4,7 @@ # This is an autogenerated file for types exported from the `spoom` gem. # Please instead update this file by running `bin/tapioca gem spoom`. + module Spoom; end module Spoom::Cli; end @@ -1577,8 +1578,8 @@ class Spoom::Deadcode::Remover::NodeContext end class Spoom::Deadcode::Remover::NodeFinder < ::Spoom::Deadcode::Visitor - sig { params(location: ::Spoom::Deadcode::Location).void } - def initialize(location); end + sig { params(location: ::Spoom::Deadcode::Location, kind: T.nilable(::Spoom::Deadcode::Definition::Kind)).void } + def initialize(location, kind); end sig { returns(T.nilable(::Prism::Node)) } def node; end diff --git a/sorbet/rbi/gems/tapioca@0.13.3-f29ea5d1cb6051bb1af4f867ff4bab39992809c3.rbi b/sorbet/rbi/gems/tapioca@0.14.3-6c258b4291a2435c93474cabfa89d94fcdbfd009.rbi similarity index 98% rename from sorbet/rbi/gems/tapioca@0.13.3-f29ea5d1cb6051bb1af4f867ff4bab39992809c3.rbi rename to sorbet/rbi/gems/tapioca@0.14.3-6c258b4291a2435c93474cabfa89d94fcdbfd009.rbi index f4d7c7307..66094d38e 100644 --- a/sorbet/rbi/gems/tapioca@0.13.3-f29ea5d1cb6051bb1af4f867ff4bab39992809c3.rbi +++ b/sorbet/rbi/gems/tapioca@0.14.3-6c258b4291a2435c93474cabfa89d94fcdbfd009.rbi @@ -4,6 +4,7 @@ # 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 @@ -105,8 +106,14 @@ class RBI::Tree < ::RBI::NodeWithComments sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) } def create_path(constant, &block); end - sig { params(parameters: T::Hash[T.any(::String, ::Symbol), ::String], return_type: ::String).returns(::RBI::Sig) } - def create_sig(parameters:, return_type: T.unsafe(nil)); end + sig do + params( + parameters: T::Hash[T.any(::String, ::Symbol), ::String], + type_parameters: T::Array[::String], + return_type: ::String + ).returns(::RBI::Sig) + end + def create_sig(parameters:, type_parameters: T.unsafe(nil), return_type: T.unsafe(nil)); end sig do params( @@ -389,6 +396,7 @@ class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracke exclude: T::Array[::String], file_header: T::Boolean, tapioca_path: ::String, + skip_constant: T::Array[::String], quiet: T::Boolean, verbose: T::Boolean, number_of_workers: T.nilable(::Integer), @@ -399,7 +407,7 @@ class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracke 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 + def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, skip_constant: T.unsafe(nil), 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 @@ -966,10 +974,11 @@ class Tapioca::Dsl::Pipeline 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, + skipped_constants: T::Array[::Module], 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 + def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil)); end sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) } def active_compilers; end @@ -1003,6 +1012,9 @@ class Tapioca::Dsl::Pipeline end def run(&blk); end + sig { returns(T::Array[::Module]) } + def skipped_constants; end + private sig { void } @@ -1022,10 +1034,11 @@ class Tapioca::Dsl::Pipeline sig do params( requested_constants: T::Array[::Module], - requested_paths: T::Array[::Pathname] + requested_paths: T::Array[::Pathname], + skipped_constants: T::Array[::Module] ).returns(T::Set[::Module]) end - def gather_constants(requested_constants, requested_paths); end + def gather_constants(requested_constants, requested_paths, skipped_constants); end sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) } def rbi_for_constant(constant); end @@ -1869,9 +1882,6 @@ class Tapioca::Loaders::Loader sig { params(path: ::String).void } def safe_require(path); end - sig { void } - def silence_deprecations; end - sig { params(blk: T.proc.void).void } def with_rails_application(&blk); end @@ -1969,6 +1979,9 @@ module Tapioca::RBIHelper sig { params(type: ::String).returns(::String) } def as_nilable_type(type); end + sig { params(type: ::String).returns(::String) } + def as_non_nilable_type(type); end + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } def create_block_param(name, type:); end