sorbet/rbi/gems/prism@0.30.0.rbi
# typed: true
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `prism` gem.
# Please instead update this file by running `bin/tapioca gem prism`.
# typed: strict
# =begin
# This file is generated by the templates/template.rb script and should not be
# modified manually. See templates/rbi/prism/node.rbi.erb
# if you are looking to modify the template
# =end
# =begin
# This file is generated by the templates/template.rb script and should not be
# modified manually. See templates/rbi/prism/visitor.rbi.erb
# if you are looking to modify the template
# =end
# We keep these shims in here because our client libraries might not have parser
# in their bundle.
module Parser; end
class Parser::Base; end
# The Prism Ruby parser.
#
# "Parsing Ruby is suddenly manageable!"
# - You, hopefully
#
# source://prism//lib/prism.rb#8
module Prism
class << self
# Mirror the Prism.dump API by using the serialization API.
def dump(*_arg0); end
# Mirror the Prism.dump_file API by using the serialization API.
def dump_file(*_arg0); end
# Mirror the Prism.lex API by using the serialization API.
def lex(*_arg0); end
# :call-seq:
# Prism::lex_compat(source, **options) -> LexCompat::Result
#
# Returns a parse result whose value is an array of tokens that closely
# resembles the return value of Ripper::lex. The main difference is that the
# `:on_sp` token is not emitted.
#
# For supported options, see Prism::parse.
#
# source://prism//lib/prism.rb#45
sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) }
def lex_compat(source, **options); end
# Mirror the Prism.lex_file API by using the serialization API.
def lex_file(*_arg0); end
# :call-seq:
# Prism::lex_ripper(source) -> Array
#
# This lexes with the Ripper lex. It drops any space events but otherwise
# returns the same tokens. Raises SyntaxError if the syntax in source is
# invalid.
#
# source://prism//lib/prism.rb#55
sig { params(source: String).returns(T::Array[T.untyped]) }
def lex_ripper(source); end
# :call-seq:
# Prism::load(source, serialized) -> ParseResult
#
# Load the serialized AST using the source as a reference into a tree.
#
# source://prism//lib/prism.rb#63
sig { params(source: String, serialized: String).returns(Prism::ParseResult) }
def load(source, serialized); end
# Mirror the Prism.parse API by using the serialization API.
def parse(*_arg0); end
# Mirror the Prism.parse_comments API by using the serialization API.
def parse_comments(*_arg0); end
# Mirror the Prism.parse_failure? API by using the serialization API.
#
# @return [Boolean]
def parse_failure?(*_arg0); end
# Mirror the Prism.parse_file API by using the serialization API. This uses
# native strings instead of Ruby strings because it allows us to use mmap
# when it is available.
def parse_file(*_arg0); end
# Mirror the Prism.parse_file_comments API by using the serialization
# API. This uses native strings instead of Ruby strings because it allows us
# to use mmap when it is available.
def parse_file_comments(*_arg0); end
# Mirror the Prism.parse_file_failure? API by using the serialization API.
#
# @return [Boolean]
def parse_file_failure?(*_arg0); end
# Mirror the Prism.parse_file_success? API by using the serialization API.
#
# @return [Boolean]
def parse_file_success?(*_arg0); end
# Mirror the Prism.parse_lex API by using the serialization API.
def parse_lex(*_arg0); end
# Mirror the Prism.parse_lex_file API by using the serialization API.
def parse_lex_file(*_arg0); end
# Mirror the Prism.parse_stream API by using the serialization API.
def parse_stream(*_arg0); end
# Mirror the Prism.parse_success? API by using the serialization API.
#
# @return [Boolean]
def parse_success?(*_arg0); end
# Mirror the Prism.profile API by using the serialization API.
def profile(*_arg0); end
# Mirror the Prism.profile_file API by using the serialization API.
def profile_file(*_arg0); end
end
end
# Specialized version of Prism::Source for source code that includes ASCII
# characters only. This class is used to apply performance optimizations that
# cannot be applied to sources that include multibyte characters. Sources that
# include multibyte characters are represented by the Prism::Source class.
#
# source://prism//lib/prism/parse_result.rb#126
class Prism::ASCIISource < ::Prism::Source
# Return the column number in characters for the given byte offset.
#
# source://prism//lib/prism/parse_result.rb#133
sig { params(byte_offset: Integer).returns(Integer) }
def character_column(byte_offset); end
# Return the character offset for the given byte offset.
#
# source://prism//lib/prism/parse_result.rb#128
sig { params(byte_offset: Integer).returns(Integer) }
def character_offset(byte_offset); end
# Specialized version of `code_units_column` that does not depend on
# `code_units_offset`, which is a more expensive operation. This is
# essentialy the same as `Prism::Source#column`.
#
# source://prism//lib/prism/parse_result.rb#150
sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
def code_units_column(byte_offset, encoding); end
# Returns the offset from the start of the file for the given byte offset
# counting in code units for the given encoding.
#
# This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
# concept of code units that differs from the number of characters in other
# encodings, it is not captured here.
#
# source://prism//lib/prism/parse_result.rb#143
sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
def code_units_offset(byte_offset, encoding); end
end
# Represents the use of the `alias` keyword to alias a global variable.
#
# alias $foo $bar
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#176
class Prism::AliasGlobalVariableNode < ::Prism::Node
# def initialize: (Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
#
# @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode
#
# source://prism//lib/prism/node.rb#178
sig do
params(
source: Prism::Source,
new_name: Prism::Node,
old_name: Prism::Node,
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, new_name, old_name, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#281
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#187
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#192
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#202
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#197
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasGlobalVariableNode
#
# source://prism//lib/prism/node.rb#207
sig do
params(
new_name: Prism::Node,
old_name: Prism::Node,
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::AliasGlobalVariableNode)
end
def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#192
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#215
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#247
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#242
sig { returns(String) }
def keyword; end
# The location of the `alias` keyword.
#
# alias $foo $bar
# ^^^^^
#
# source://prism//lib/prism/node.rb#235
sig { returns(Prism::Location) }
def keyword_loc; end
# Represents the new name of the global variable that can be used after aliasing. This can be either a global variable, a back reference, or a numbered reference.
#
# alias $foo $bar
# ^^^^
#
# source://prism//lib/prism/node.rb#223
sig { returns(Prism::Node) }
def new_name; end
# Represents the old name of the global variable that could be used before aliasing. This can be either a global variable, a back reference, or a numbered reference.
#
# alias $foo $bar
# ^^^^
#
# source://prism//lib/prism/node.rb#229
sig { returns(Prism::Node) }
def old_name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#265
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#275
def type; end
end
end
# Represents the use of the `alias` keyword to alias a method.
#
# alias foo bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#293
class Prism::AliasMethodNode < ::Prism::Node
# def initialize: (Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
#
# @return [AliasMethodNode] a new instance of AliasMethodNode
#
# source://prism//lib/prism/node.rb#295
sig do
params(
source: Prism::Source,
new_name: Prism::Node,
old_name: Prism::Node,
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, new_name, old_name, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#389
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#304
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#319
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#314
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasMethodNode
#
# source://prism//lib/prism/node.rb#324
sig do
params(
new_name: Prism::Node,
old_name: Prism::Node,
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::AliasMethodNode)
end
def copy(new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#332
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#355
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#350
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#343
sig { returns(Prism::Location) }
def keyword_loc; end
# attr_reader new_name: Prism::node
#
# source://prism//lib/prism/node.rb#337
sig { returns(Prism::Node) }
def new_name; end
# attr_reader old_name: Prism::node
#
# source://prism//lib/prism/node.rb#340
sig { returns(Prism::Node) }
def old_name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#373
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#383
def type; end
end
end
# Represents an alternation pattern in pattern matching.
#
# foo => bar | baz
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#401
class Prism::AlternationPatternNode < ::Prism::Node
# def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
#
# @return [AlternationPatternNode] a new instance of AlternationPatternNode
#
# source://prism//lib/prism/node.rb#403
sig do
params(
source: Prism::Source,
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, left, right, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#497
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#412
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#417
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#427
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#422
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AlternationPatternNode
#
# source://prism//lib/prism/node.rb#432
sig do
params(
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::AlternationPatternNode)
end
def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#417
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#440
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#463
sig { override.returns(String) }
def inspect; end
# attr_reader left: Prism::node
#
# source://prism//lib/prism/node.rb#445
sig { returns(Prism::Node) }
def left; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#458
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#451
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader right: Prism::node
#
# source://prism//lib/prism/node.rb#448
sig { returns(Prism::Node) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#481
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#491
def type; end
end
end
# Represents the use of the `&&` operator or the `and` keyword.
#
# left and right
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#509
class Prism::AndNode < ::Prism::Node
# def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
#
# @return [AndNode] a new instance of AndNode
#
# source://prism//lib/prism/node.rb#511
sig do
params(
source: Prism::Source,
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, left, right, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#620
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#520
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#525
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#535
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#530
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AndNode
#
# source://prism//lib/prism/node.rb#540
sig do
params(
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::AndNode)
end
def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#525
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#548
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#586
sig { override.returns(String) }
def inspect; end
# Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# left and right
# ^^^^
#
# 1 && 2
# ^
#
# source://prism//lib/prism/node.rb#559
sig { returns(Prism::Node) }
def left; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#581
sig { returns(String) }
def operator; end
# The location of the `and` keyword or the `&&` operator.
#
# left and right
# ^^^
#
# source://prism//lib/prism/node.rb#574
sig { returns(Prism::Location) }
def operator_loc; end
# Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# left && right
# ^^^^^
#
# 1 and 2
# ^
#
# source://prism//lib/prism/node.rb#568
sig { returns(Prism::Node) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#604
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#614
def type; end
end
end
# Represents a set of arguments to a method or a keyword.
#
# return foo, bar, baz
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#632
class Prism::ArgumentsNode < ::Prism::Node
# def initialize: (Integer flags, Array[Prism::node] arguments, Location location) -> void
#
# @return [ArgumentsNode] a new instance of ArgumentsNode
#
# source://prism//lib/prism/node.rb#634
sig do
params(
source: Prism::Source,
flags: Integer,
arguments: T::Array[Prism::Node],
location: Prism::Location
).void
end
def initialize(source, flags, arguments, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#726
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#642
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#679
sig { returns(T::Array[Prism::Node]) }
def arguments; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#647
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#657
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#652
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def contains_keyword_splat?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#687
sig { returns(T::Boolean) }
def contains_keyword_splat?; end
# def contains_keywords?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#682
sig { returns(T::Boolean) }
def contains_keywords?; end
# def copy: (?flags: Integer, ?arguments: Array[Prism::node], ?location: Location) -> ArgumentsNode
#
# source://prism//lib/prism/node.rb#662
sig do
params(
flags: Integer,
arguments: T::Array[Prism::Node],
location: Prism::Location
).returns(Prism::ArgumentsNode)
end
def copy(flags: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#647
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, arguments: Array[Prism::node], location: Location }
#
# source://prism//lib/prism/node.rb#670
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#692
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#710
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#675
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#720
def type; end
end
end
# Flags for arguments nodes.
#
# source://prism//lib/prism/node.rb#19127
module Prism::ArgumentsNodeFlags; end
# if arguments contain keywords
#
# source://prism//lib/prism/node.rb#19129
Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer)
# if arguments contain keyword splat
#
# source://prism//lib/prism/node.rb#19132
Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer)
# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
#
# [1, 2, 3]
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#738
class Prism::ArrayNode < ::Prism::Node
# def initialize: (Integer flags, Array[Prism::node] elements, Location? opening_loc, Location? closing_loc, Location location) -> void
#
# @return [ArrayNode] a new instance of ArrayNode
#
# source://prism//lib/prism/node.rb#740
sig do
params(
source: Prism::Source,
flags: Integer,
elements: T::Array[Prism::Node],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, flags, elements, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#875
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#750
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#755
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#836
sig { returns(T.nilable(String)) }
def closing; end
# Represents the optional source location for the closing token.
#
# [1,2,3] # "]"
# %w[foo bar baz] # "]"
# %I(apple orange banana) # ")"
# foo = 1, 2, 3 # nil
#
# source://prism//lib/prism/node.rb#813
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#765
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#760
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def contains_splat?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#826
sig { returns(T::Boolean) }
def contains_splat?; end
# def copy: (?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayNode
#
# source://prism//lib/prism/node.rb#770
sig do
params(
flags: Integer,
elements: T::Array[Prism::Node],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::ArrayNode)
end
def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#755
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#778
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
#
# source://prism//lib/prism/node.rb#787
sig { returns(T::Array[Prism::Node]) }
def elements; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#841
sig { override.returns(String) }
def inspect; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#831
sig { returns(T.nilable(String)) }
def opening; end
# Represents the optional source location for the opening token.
#
# [1,2,3] # "["
# %w[foo bar baz] # "%w["
# %I(apple orange banana) # "%I("
# foo = 1, 2, 3 # nil
#
# source://prism//lib/prism/node.rb#795
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#859
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#783
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#869
def type; end
end
end
# Flags for array nodes.
#
# source://prism//lib/prism/node.rb#19136
module Prism::ArrayNodeFlags; end
# if array contains splat nodes
#
# source://prism//lib/prism/node.rb#19138
Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer)
# Represents an array pattern in pattern matching.
#
# foo in 1, 2
# ^^^^^^^^^^^
#
# foo in [1, 2]
# ^^^^^^^^^^^^^
#
# foo in *1
# ^^^^^^^^^
#
# foo in Bar[]
# ^^^^^^^^^^^^
#
# foo in Bar[1, 2, 3]
# ^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#901
class Prism::ArrayPatternNode < ::Prism::Node
# def initialize: (Prism::node? constant, Array[Prism::node] requireds, Prism::node? rest, Array[Prism::node] posts, Location? opening_loc, Location? closing_loc, Location location) -> void
#
# @return [ArrayPatternNode] a new instance of ArrayPatternNode
#
# source://prism//lib/prism/node.rb#903
sig do
params(
source: Prism::Source,
constant: T.nilable(Prism::Node),
requireds: T::Array[Prism::Node],
rest: T.nilable(Prism::Node),
posts: T::Array[Prism::Node],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, constant, requireds, rest, posts, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1035
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#915
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#920
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#996
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#978
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#935
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#925
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader constant: Prism::node?
#
# source://prism//lib/prism/node.rb#953
sig { returns(T.nilable(Prism::Node)) }
def constant; end
# def copy: (?constant: Prism::node?, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayPatternNode
#
# source://prism//lib/prism/node.rb#940
sig do
params(
constant: T.nilable(Prism::Node),
requireds: T::Array[Prism::Node],
rest: T.nilable(Prism::Node),
posts: T::Array[Prism::Node],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::ArrayPatternNode)
end
def copy(constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#920
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#948
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1001
sig { override.returns(String) }
def inspect; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#991
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#965
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader posts: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#962
sig { returns(T::Array[Prism::Node]) }
def posts; end
# attr_reader requireds: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#956
sig { returns(T::Array[Prism::Node]) }
def requireds; end
# attr_reader rest: Prism::node?
#
# source://prism//lib/prism/node.rb#959
sig { returns(T.nilable(Prism::Node)) }
def rest; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1019
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1029
def type; end
end
end
# Represents a hash key/value pair.
#
# { a => b }
# ^^^^^^
#
# source://prism//lib/prism/node.rb#1052
class Prism::AssocNode < ::Prism::Node
# def initialize: (Prism::node key, Prism::node value, Location? operator_loc, Location location) -> void
#
# @return [AssocNode] a new instance of AssocNode
#
# source://prism//lib/prism/node.rb#1054
sig do
params(
source: Prism::Source,
key: Prism::Node,
value: Prism::Node,
operator_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, key, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1172
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1063
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1068
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1078
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1073
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?, ?location: Location) -> AssocNode
#
# source://prism//lib/prism/node.rb#1083
sig do
params(
key: Prism::Node,
value: Prism::Node,
operator_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::AssocNode)
end
def copy(key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1068
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { key: Prism::node, value: Prism::node, operator_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#1091
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1138
sig { override.returns(String) }
def inspect; end
# The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# { a: b }
# ^
#
# { foo => bar }
# ^^^
#
# { def a; end => 1 }
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#1105
sig { returns(Prism::Node) }
def key; end
# def operator: () -> String?
#
# source://prism//lib/prism/node.rb#1133
sig { returns(T.nilable(String)) }
def operator; end
# The location of the `=>` operator, if present.
#
# { foo => bar }
# ^^
#
# source://prism//lib/prism/node.rb#1120
sig { returns(T.nilable(Prism::Location)) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1156
sig { override.returns(Symbol) }
def type; end
# The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# { foo => bar }
# ^^^
#
# { x: 1 }
# ^
#
# source://prism//lib/prism/node.rb#1114
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1166
def type; end
end
end
# Represents a splat in a hash literal.
#
# { **foo }
# ^^^^^
#
# source://prism//lib/prism/node.rb#1184
class Prism::AssocSplatNode < ::Prism::Node
# def initialize: (Prism::node? value, Location operator_loc, Location location) -> void
#
# @return [AssocSplatNode] a new instance of AssocSplatNode
#
# source://prism//lib/prism/node.rb#1186
sig do
params(
source: Prism::Source,
value: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1284
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1194
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1199
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1211
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1204
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Prism::node?, ?operator_loc: Location, ?location: Location) -> AssocSplatNode
#
# source://prism//lib/prism/node.rb#1216
sig do
params(
value: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::AssocSplatNode)
end
def copy(value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1199
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#1224
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1250
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#1245
sig { returns(String) }
def operator; end
# The location of the `**` operator.
#
# { **x }
# ^^
#
# source://prism//lib/prism/node.rb#1238
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1268
sig { override.returns(Symbol) }
def type; end
# The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
#
# { **foo }
# ^^^
#
# source://prism//lib/prism/node.rb#1232
sig { returns(T.nilable(Prism::Node)) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1278
def type; end
end
end
# The FFI backend is used on other Ruby implementations.
#
# source://prism//lib/prism.rb#81
Prism::BACKEND = T.let(T.unsafe(nil), Symbol)
# Represents reading a reference to a field in the previous match.
#
# $'
# ^^
#
# source://prism//lib/prism/node.rb#1295
class Prism::BackReferenceReadNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [BackReferenceReadNode] a new instance of BackReferenceReadNode
#
# source://prism//lib/prism/node.rb#1297
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1378
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1304
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1319
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1314
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> BackReferenceReadNode
#
# source://prism//lib/prism/node.rb#1324
sig { params(name: Symbol, location: Prism::Location).returns(Prism::BackReferenceReadNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#1332
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1344
sig { override.returns(String) }
def inspect; end
# The name of the back-reference variable, including the leading `$`.
#
# $& # name `:$&`
#
# $+ # name `:$+`
#
# source://prism//lib/prism/node.rb#1341
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1362
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1372
def type; end
end
end
# A class that knows how to walk down the tree. None of the individual visit
# methods are implemented on this visitor, so it forces the consumer to
# implement each one that they need. For a default implementation that
# continues walking the tree, see the Visitor class.
#
# source://prism//lib/prism/visitor.rb#14
class Prism::BasicVisitor
# Calls `accept` on the given node if it is not `nil`, which in turn should
# call back into this visitor by calling the appropriate `visit_*` method.
#
# source://prism//lib/prism/visitor.rb#17
sig { params(node: T.nilable(Prism::Node)).void }
def visit(node); end
# Visits each node in `nodes` by calling `accept` on each one.
#
# source://prism//lib/prism/visitor.rb#23
sig { params(nodes: T::Array[T.nilable(Prism::Node)]).void }
def visit_all(nodes); end
# Visits the child nodes of `node` by calling `accept` on each one.
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::Node).void }
def visit_child_nodes(node); end
end
# Represents a begin statement.
#
# begin
# foo
# end
# ^^^^^
#
# source://prism//lib/prism/node.rb#1390
class Prism::BeginNode < ::Prism::Node
# def initialize: (Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc, Location location) -> void
#
# @return [BeginNode] a new instance of BeginNode
#
# source://prism//lib/prism/node.rb#1392
sig do
params(
source: Prism::Source,
begin_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
rescue_clause: T.nilable(Prism::RescueNode),
else_clause: T.nilable(Prism::ElseNode),
ensure_clause: T.nilable(Prism::EnsureNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1524
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1404
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def begin_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#1480
sig { returns(T.nilable(String)) }
def begin_keyword; end
# attr_reader begin_keyword_loc: Location?
#
# source://prism//lib/prism/node.rb#1442
sig { returns(T.nilable(Prism::Location)) }
def begin_keyword_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1409
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1424
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1414
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?, ?location: Location) -> BeginNode
#
# source://prism//lib/prism/node.rb#1429
sig do
params(
begin_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
rescue_clause: T.nilable(Prism::RescueNode),
else_clause: T.nilable(Prism::ElseNode),
ensure_clause: T.nilable(Prism::EnsureNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::BeginNode)
end
def copy(begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1409
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#1437
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader else_clause: ElseNode?
#
# source://prism//lib/prism/node.rb#1461
sig { returns(T.nilable(Prism::ElseNode)) }
def else_clause; end
# def end_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#1485
sig { returns(T.nilable(String)) }
def end_keyword; end
# attr_reader end_keyword_loc: Location?
#
# source://prism//lib/prism/node.rb#1467
sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end
# attr_reader ensure_clause: EnsureNode?
#
# source://prism//lib/prism/node.rb#1464
sig { returns(T.nilable(Prism::EnsureNode)) }
def ensure_clause; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1490
sig { override.returns(String) }
def inspect; end
# source://prism//lib/prism/parse_result/newlines.rb#79
def newline!(lines); end
# attr_reader rescue_clause: RescueNode?
#
# source://prism//lib/prism/node.rb#1458
sig { returns(T.nilable(Prism::RescueNode)) }
def rescue_clause; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#1455
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1508
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1518
def type; end
end
end
# Represents block method arguments.
#
# bar(&args)
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#1539
class Prism::BlockArgumentNode < ::Prism::Node
# def initialize: (Prism::node? expression, Location operator_loc, Location location) -> void
#
# @return [BlockArgumentNode] a new instance of BlockArgumentNode
#
# source://prism//lib/prism/node.rb#1541
sig do
params(
source: Prism::Source,
expression: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, expression, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1633
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1549
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1554
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1566
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1559
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?expression: Prism::node?, ?operator_loc: Location, ?location: Location) -> BlockArgumentNode
#
# source://prism//lib/prism/node.rb#1571
sig do
params(
expression: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::BlockArgumentNode)
end
def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1554
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#1579
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader expression: Prism::node?
#
# source://prism//lib/prism/node.rb#1584
sig { returns(T.nilable(Prism::Node)) }
def expression; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1599
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#1594
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#1587
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1617
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1627
def type; end
end
end
# Represents a block local variable.
#
# a { |; b| }
# ^
#
# source://prism//lib/prism/node.rb#1644
class Prism::BlockLocalVariableNode < ::Prism::Node
# def initialize: (Integer flags, Symbol name, Location location) -> void
#
# @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode
#
# source://prism//lib/prism/node.rb#1646
sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void }
def initialize(source, flags, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1733
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1654
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1659
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1669
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1664
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> BlockLocalVariableNode
#
# source://prism//lib/prism/node.rb#1674
sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::BlockLocalVariableNode) }
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1659
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#1682
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1699
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#1691
sig { returns(Symbol) }
def name; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#1694
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1717
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#1687
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1727
def type; end
end
end
# Represents a block of ruby code.
#
# [1, 2, 3].each { |i| puts x }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#1744
class Prism::BlockNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, Prism::node? parameters, Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
#
# @return [BlockNode] a new instance of BlockNode
#
# source://prism//lib/prism/node.rb#1746
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
parameters: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, locals, parameters, body, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1860
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1757
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#1799
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1762
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#1821
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#1809
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1775
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1767
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?locals: Array[Symbol], ?parameters: Prism::node?, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> BlockNode
#
# source://prism//lib/prism/node.rb#1780
sig do
params(
locals: T::Array[Symbol],
parameters: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::BlockNode)
end
def copy(locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1762
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], parameters: Prism::node?, body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#1788
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1826
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#1793
sig { returns(T::Array[Symbol]) }
def locals; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#1816
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#1802
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader parameters: Prism::node?
#
# source://prism//lib/prism/node.rb#1796
sig { returns(T.nilable(Prism::Node)) }
def parameters; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1844
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1854
def type; end
end
end
# Represents a block parameter to a method, block, or lambda definition.
#
# def a(&b)
# ^^
# end
#
# source://prism//lib/prism/node.rb#1876
class Prism::BlockParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
#
# @return [BlockParameterNode] a new instance of BlockParameterNode
#
# source://prism//lib/prism/node.rb#1878
sig do
params(
source: Prism::Source,
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#1992
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#1888
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1893
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#1903
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#1898
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> BlockParameterNode
#
# source://prism//lib/prism/node.rb#1908
sig do
params(
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::BlockParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#1893
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#1916
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#1958
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol?
#
# source://prism//lib/prism/node.rb#1925
sig { returns(T.nilable(Symbol)) }
def name; end
# attr_reader name_loc: Location?
#
# source://prism//lib/prism/node.rb#1928
sig { returns(T.nilable(Prism::Location)) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#1953
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#1941
sig { returns(Prism::Location) }
def operator_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#1948
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1976
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#1921
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#1986
def type; end
end
end
# Represents a block's parameters declaration.
#
# -> (a, b = 1; local) { }
# ^^^^^^^^^^^^^^^^^
#
# foo do |a, b = 1; local|
# ^^^^^^^^^^^^^^^^^
# end
#
# source://prism//lib/prism/node.rb#2009
class Prism::BlockParametersNode < ::Prism::Node
# def initialize: (ParametersNode? parameters, Array[BlockLocalVariableNode] locals, Location? opening_loc, Location? closing_loc, Location location) -> void
#
# @return [BlockParametersNode] a new instance of BlockParametersNode
#
# source://prism//lib/prism/node.rb#2011
sig do
params(
source: Prism::Source,
parameters: T.nilable(Prism::ParametersNode),
locals: T::Array[Prism::BlockLocalVariableNode],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, parameters, locals, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#2133
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2021
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2026
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#2094
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#2076
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2039
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2031
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> BlockParametersNode
#
# source://prism//lib/prism/node.rb#2044
sig do
params(
parameters: T.nilable(Prism::ParametersNode),
locals: T::Array[Prism::BlockLocalVariableNode],
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::BlockParametersNode)
end
def copy(parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2026
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#2052
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#2099
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[BlockLocalVariableNode]
#
# source://prism//lib/prism/node.rb#2060
sig { returns(T::Array[Prism::BlockLocalVariableNode]) }
def locals; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#2089
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#2063
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader parameters: ParametersNode?
#
# source://prism//lib/prism/node.rb#2057
sig { returns(T.nilable(Prism::ParametersNode)) }
def parameters; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2117
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2127
def type; end
end
end
# Represents the use of the `break` keyword.
#
# break foo
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#2147
class Prism::BreakNode < ::Prism::Node
# def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
#
# @return [BreakNode] a new instance of BreakNode
#
# source://prism//lib/prism/node.rb#2149
sig do
params(
source: Prism::Source,
arguments: T.nilable(Prism::ArgumentsNode),
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, arguments, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#2247
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2157
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# break foo
# ^^^
#
# source://prism//lib/prism/node.rb#2195
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2162
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2174
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2167
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> BreakNode
#
# source://prism//lib/prism/node.rb#2179
sig do
params(
arguments: T.nilable(Prism::ArgumentsNode),
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::BreakNode)
end
def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2162
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#2187
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#2213
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#2208
sig { returns(String) }
def keyword; end
# The location of the `break` keyword.
#
# break foo
# ^^^^^
#
# source://prism//lib/prism/node.rb#2201
sig { returns(Prism::Location) }
def keyword_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2231
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2241
def type; end
end
end
# Represents the use of the `&&=` operator on a call.
#
# foo.bar &&= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#2258
class Prism::CallAndWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [CallAndWriteNode] a new instance of CallAndWriteNode
#
# source://prism//lib/prism/node.rb#2260
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#2428
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2274
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2369
sig { returns(T::Boolean) }
def attribute_write?; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#2379
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#2317
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2279
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2292
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2284
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallAndWriteNode
#
# source://prism//lib/prism/node.rb#2297
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::CallAndWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2279
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#2305
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2374
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#2394
sig { override.returns(String) }
def inspect; end
# def message: () -> String?
#
# source://prism//lib/prism/node.rb#2384
sig { returns(T.nilable(String)) }
def message; end
# attr_reader message_loc: Location?
#
# source://prism//lib/prism/node.rb#2330
sig { returns(T.nilable(Prism::Location)) }
def message_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#2389
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#2349
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader read_name: Symbol
#
# source://prism//lib/prism/node.rb#2343
sig { returns(Symbol) }
def read_name; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#2314
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2359
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2412
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#2356
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2364
sig { returns(T::Boolean) }
def variable_call?; end
# attr_reader write_name: Symbol
#
# source://prism//lib/prism/node.rb#2346
sig { returns(Symbol) }
def write_name; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#2310
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2422
def type; end
end
end
# Represents a method call, in all of the various forms that can take.
#
# foo
# ^^^
#
# foo()
# ^^^^^
#
# +foo
# ^^^^
#
# foo + bar
# ^^^^^^^^^
#
# foo.bar
# ^^^^^^^
#
# foo&.bar
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#2460
class Prism::CallNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Prism::node? block, Location location) -> void
#
# @return [CallNode] a new instance of CallNode
#
# source://prism//lib/prism/node.rb#2462
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
name: Symbol,
message_loc: T.nilable(Prism::Location),
opening_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: T.nilable(Prism::Location),
block: T.nilable(Prism::Node),
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#2665
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2477
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#2572
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2601
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#2588
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#2611
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#2530
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2482
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#2626
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#2575
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2496
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2487
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: Prism::node?, ?location: Location) -> CallNode
#
# source://prism//lib/prism/node.rb#2501
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
name: Symbol,
message_loc: T.nilable(Prism::Location),
opening_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: T.nilable(Prism::Location),
block: T.nilable(Prism::Node),
location: Prism::Location
).returns(Prism::CallNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2482
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Prism::node?, location: Location }
#
# source://prism//lib/prism/node.rb#2509
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# When a call node has the attribute_write flag set, it means that the call
# is using the attribute write syntax. This is either a method call to []=
# or a method call to a method that ends with =. Either way, the = sign is
# present in the source.
#
# Prism returns the message_loc _without_ the = sign attached, because there
# can be any amount of space between the message and the = sign. However,
# sometimes you want the location of the full message including the inner
# space and the = sign. This method provides that.
#
# source://prism//lib/prism/node_ext.rb#315
sig { returns(T.nilable(Prism::Location)) }
def full_message_loc; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2606
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#2631
sig { override.returns(String) }
def inspect; end
# def message: () -> String?
#
# source://prism//lib/prism/node.rb#2616
sig { returns(T.nilable(String)) }
def message; end
# attr_reader message_loc: Location?
#
# source://prism//lib/prism/node.rb#2546
sig { returns(T.nilable(Prism::Location)) }
def message_loc; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#2543
sig { returns(Symbol) }
def name; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#2621
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#2559
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# foo.bar
# ^^^
#
# +foo
# ^^^
#
# foo + bar
# ^^^
#
# source://prism//lib/prism/node.rb#2527
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2591
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2649
sig { override.returns(Symbol) }
def type; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2596
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#2514
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2659
def type; end
end
end
# Flags for call nodes.
#
# source://prism//lib/prism/node.rb#19142
module Prism::CallNodeFlags; end
# a call that is an attribute write, so the value being written should be returned
#
# source://prism//lib/prism/node.rb#19150
Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer)
# a call that ignores method visibility
#
# source://prism//lib/prism/node.rb#19153
Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer)
# &. operator
#
# source://prism//lib/prism/node.rb#19144
Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer)
# a call that could have been a local variable
#
# source://prism//lib/prism/node.rb#19147
Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer)
# Represents the use of an assignment operator on a call.
#
# foo.bar += baz
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#2683
class Prism::CallOperatorWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
#
# @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode
#
# source://prism//lib/prism/node.rb#2685
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
binary_operator: Symbol,
binary_operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#2852
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2700
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2798
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#2775
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#2778
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#2808
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#2743
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2705
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2718
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2710
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
#
# source://prism//lib/prism/node.rb#2723
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
binary_operator: Symbol,
binary_operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::CallOperatorWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2705
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#2731
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2803
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#2818
sig { override.returns(String) }
def inspect; end
# def message: () -> String?
#
# source://prism//lib/prism/node.rb#2813
sig { returns(T.nilable(String)) }
def message; end
# attr_reader message_loc: Location?
#
# source://prism//lib/prism/node.rb#2756
sig { returns(T.nilable(Prism::Location)) }
def message_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#323
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#330
def operator_loc; end
# attr_reader read_name: Symbol
#
# source://prism//lib/prism/node.rb#2769
sig { returns(Symbol) }
def read_name; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#2740
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2788
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2836
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#2785
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2793
sig { returns(T::Boolean) }
def variable_call?; end
# attr_reader write_name: Symbol
#
# source://prism//lib/prism/node.rb#2772
sig { returns(Symbol) }
def write_name; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#2736
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#2846
def type; end
end
end
# Represents the use of the `||=` operator on a call.
#
# foo.bar ||= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#2870
class Prism::CallOrWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [CallOrWriteNode] a new instance of CallOrWriteNode
#
# source://prism//lib/prism/node.rb#2872
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3040
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#2886
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2981
sig { returns(T::Boolean) }
def attribute_write?; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#2991
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#2929
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2891
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#2904
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#2896
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOrWriteNode
#
# source://prism//lib/prism/node.rb#2909
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
message_loc: T.nilable(Prism::Location),
read_name: Symbol,
write_name: Symbol,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::CallOrWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#2891
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#2917
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2986
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3006
sig { override.returns(String) }
def inspect; end
# def message: () -> String?
#
# source://prism//lib/prism/node.rb#2996
sig { returns(T.nilable(String)) }
def message; end
# attr_reader message_loc: Location?
#
# source://prism//lib/prism/node.rb#2942
sig { returns(T.nilable(Prism::Location)) }
def message_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#3001
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#2961
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader read_name: Symbol
#
# source://prism//lib/prism/node.rb#2955
sig { returns(Symbol) }
def read_name; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#2926
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2971
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3024
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#2968
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#2976
sig { returns(T::Boolean) }
def variable_call?; end
# attr_reader write_name: Symbol
#
# source://prism//lib/prism/node.rb#2958
sig { returns(Symbol) }
def write_name; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#2922
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3034
def type; end
end
end
# Represents assigning to a method call.
#
# foo.bar, = 1
# ^^^^^^^
#
# begin
# rescue => foo.bar
# ^^^^^^^
# end
#
# for foo.bar in baz do end
# ^^^^^^^
#
# source://prism//lib/prism/node.rb#3065
class Prism::CallTargetNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node receiver, Location call_operator_loc, Symbol name, Location message_loc, Location location) -> void
#
# @return [CallTargetNode] a new instance of CallTargetNode
#
# source://prism//lib/prism/node.rb#3067
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: Prism::Node,
call_operator_loc: Prism::Location,
name: Symbol,
message_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, name, message_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3199
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3078
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#3145
sig { returns(T::Boolean) }
def attribute_write?; end
# def call_operator: () -> String
#
# source://prism//lib/prism/node.rb#3155
sig { returns(String) }
def call_operator; end
# attr_reader call_operator_loc: Location
#
# source://prism//lib/prism/node.rb#3118
sig { returns(Prism::Location) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3083
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3093
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3088
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location, ?location: Location) -> CallTargetNode
#
# source://prism//lib/prism/node.rb#3098
sig do
params(
flags: Integer,
receiver: Prism::Node,
call_operator_loc: Prism::Location,
name: Symbol,
message_loc: Prism::Location,
location: Prism::Location
).returns(Prism::CallTargetNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3083
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#3106
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#3150
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3165
sig { override.returns(String) }
def inspect; end
# def message: () -> String
#
# source://prism//lib/prism/node.rb#3160
sig { returns(String) }
def message; end
# attr_reader message_loc: Location
#
# source://prism//lib/prism/node.rb#3128
sig { returns(Prism::Location) }
def message_loc; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#3125
sig { returns(Symbol) }
def name; end
# attr_reader receiver: Prism::node
#
# source://prism//lib/prism/node.rb#3115
sig { returns(Prism::Node) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#3135
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3183
sig { override.returns(Symbol) }
def type; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#3140
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#3111
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3193
def type; end
end
end
# Represents assigning to a local variable in pattern matching.
#
# foo => [bar => baz]
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3213
class Prism::CapturePatternNode < ::Prism::Node
# def initialize: (Prism::node value, Prism::node target, Location operator_loc, Location location) -> void
#
# @return [CapturePatternNode] a new instance of CapturePatternNode
#
# source://prism//lib/prism/node.rb#3215
sig do
params(
source: Prism::Source,
value: Prism::Node,
target: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, value, target, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3309
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3224
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3229
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3239
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3234
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Prism::node, ?target: Prism::node, ?operator_loc: Location, ?location: Location) -> CapturePatternNode
#
# source://prism//lib/prism/node.rb#3244
sig do
params(
value: Prism::Node,
target: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::CapturePatternNode)
end
def copy(value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3229
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, target: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#3252
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3275
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#3270
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#3263
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader target: Prism::node
#
# source://prism//lib/prism/node.rb#3260
sig { returns(Prism::Node) }
def target; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3293
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#3257
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3303
def type; end
end
end
# Represents the use of a case statement for pattern matching.
#
# case true
# in false
# end
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3323
class Prism::CaseMatchNode < ::Prism::Node
# def initialize: (Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
#
# @return [CaseMatchNode] a new instance of CaseMatchNode
#
# source://prism//lib/prism/node.rb#3325
sig do
params(
source: Prism::Source,
predicate: T.nilable(Prism::Node),
conditions: T::Array[Prism::Node],
consequent: T.nilable(Prism::ElseNode),
case_keyword_loc: Prism::Location,
end_keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3440
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3336
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def case_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3396
sig { returns(String) }
def case_keyword; end
# attr_reader case_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3382
sig { returns(Prism::Location) }
def case_keyword_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3341
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3355
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3346
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader conditions: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#3376
sig { returns(T::Array[Prism::Node]) }
def conditions; end
# attr_reader consequent: ElseNode?
#
# source://prism//lib/prism/node.rb#3379
sig { returns(T.nilable(Prism::ElseNode)) }
def consequent; end
# def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseMatchNode
#
# source://prism//lib/prism/node.rb#3360
sig do
params(
predicate: T.nilable(Prism::Node),
conditions: T::Array[Prism::Node],
consequent: T.nilable(Prism::ElseNode),
case_keyword_loc: Prism::Location,
end_keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::CaseMatchNode)
end
def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3341
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#3368
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3401
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3389
sig { returns(Prism::Location) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3406
sig { override.returns(String) }
def inspect; end
# attr_reader predicate: Prism::node?
#
# source://prism//lib/prism/node.rb#3373
sig { returns(T.nilable(Prism::Node)) }
def predicate; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3424
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3434
def type; end
end
end
# Represents the use of a case statement.
#
# case true
# when false
# end
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3457
class Prism::CaseNode < ::Prism::Node
# def initialize: (Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
#
# @return [CaseNode] a new instance of CaseNode
#
# source://prism//lib/prism/node.rb#3459
sig do
params(
source: Prism::Source,
predicate: T.nilable(Prism::Node),
conditions: T::Array[Prism::Node],
consequent: T.nilable(Prism::ElseNode),
case_keyword_loc: Prism::Location,
end_keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3574
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3470
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def case_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3530
sig { returns(String) }
def case_keyword; end
# attr_reader case_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3516
sig { returns(Prism::Location) }
def case_keyword_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3475
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3489
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3480
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader conditions: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#3510
sig { returns(T::Array[Prism::Node]) }
def conditions; end
# attr_reader consequent: ElseNode?
#
# source://prism//lib/prism/node.rb#3513
sig { returns(T.nilable(Prism::ElseNode)) }
def consequent; end
# def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseNode
#
# source://prism//lib/prism/node.rb#3494
sig do
params(
predicate: T.nilable(Prism::Node),
conditions: T::Array[Prism::Node],
consequent: T.nilable(Prism::ElseNode),
case_keyword_loc: Prism::Location,
end_keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::CaseNode)
end
def copy(predicate: T.unsafe(nil), conditions: T.unsafe(nil), consequent: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3475
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#3502
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3535
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3523
sig { returns(Prism::Location) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3540
sig { override.returns(String) }
def inspect; end
# attr_reader predicate: Prism::node?
#
# source://prism//lib/prism/node.rb#3507
sig { returns(T.nilable(Prism::Node)) }
def predicate; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3558
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3568
def type; end
end
end
# Represents a class declaration involving the `class` keyword.
#
# class Foo end
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3589
class Prism::ClassNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, Location class_keyword_loc, Prism::node constant_path, Location? inheritance_operator_loc, Prism::node? superclass, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
#
# @return [ClassNode] a new instance of ClassNode
#
# source://prism//lib/prism/node.rb#3591
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
class_keyword_loc: Prism::Location,
constant_path: Prism::Node,
inheritance_operator_loc: T.nilable(Prism::Location),
superclass: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
name: Symbol,
location: Prism::Location
).void
end
def initialize(source, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3733
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3605
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#3671
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3610
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def class_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3684
sig { returns(String) }
def class_keyword; end
# attr_reader class_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3645
sig { returns(Prism::Location) }
def class_keyword_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3624
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3615
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader constant_path: Prism::node
#
# source://prism//lib/prism/node.rb#3652
sig { returns(Prism::Node) }
def constant_path; end
# def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: Prism::node, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ClassNode
#
# source://prism//lib/prism/node.rb#3629
sig do
params(
locals: T::Array[Symbol],
class_keyword_loc: Prism::Location,
constant_path: Prism::Node,
inheritance_operator_loc: T.nilable(Prism::Location),
superclass: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
name: Symbol,
location: Prism::Location
).returns(Prism::ClassNode)
end
def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3610
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, constant_path: Prism::node, inheritance_operator_loc: Location?, superclass: Prism::node?, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#3637
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#3694
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#3674
sig { returns(Prism::Location) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inheritance_operator: () -> String?
#
# source://prism//lib/prism/node.rb#3689
sig { returns(T.nilable(String)) }
def inheritance_operator; end
# attr_reader inheritance_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#3655
sig { returns(T.nilable(Prism::Location)) }
def inheritance_operator_loc; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3699
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#3642
sig { returns(T::Array[Symbol]) }
def locals; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#3681
sig { returns(Symbol) }
def name; end
# attr_reader superclass: Prism::node?
#
# source://prism//lib/prism/node.rb#3668
sig { returns(T.nilable(Prism::Node)) }
def superclass; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3717
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3727
def type; end
end
end
# Represents the use of the `&&=` operator for assignment to a class variable.
#
# @@target &&= value
# ^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3751
class Prism::ClassVariableAndWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#3753
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3855
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3763
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3768
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3778
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3773
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#3783
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ClassVariableAndWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3768
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#3791
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#127
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3821
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#3796
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#3799
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#3816
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#3806
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3839
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#3813
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3849
def type; end
end
end
# Represents assigning to a class variable using an operator that isn't `=`.
#
# @@target += value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3868
class Prism::ClassVariableOperatorWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
#
# @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#3870
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#3971
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3881
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#3934
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#3924
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3886
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#3896
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#3891
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#3901
sig do
params(
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).returns(Prism::ClassVariableOperatorWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#3886
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#3909
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#139
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#3937
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#3914
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#3917
sig { returns(Prism::Location) }
def name_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#339
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#346
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3955
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#3931
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#3965
def type; end
end
end
# Represents the use of the `||=` operator for assignment to a class variable.
#
# @@target ||= value
# ^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#3985
class Prism::ClassVariableOrWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#3987
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4089
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#3997
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4012
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4007
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#4017
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ClassVariableOrWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#4025
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#133
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4055
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#4030
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#4033
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#4050
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#4040
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4073
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#4047
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4083
def type; end
end
end
# Represents referencing a class variable.
#
# @@foo
# ^^^^^
#
# source://prism//lib/prism/node.rb#4102
class Prism::ClassVariableReadNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [ClassVariableReadNode] a new instance of ClassVariableReadNode
#
# source://prism//lib/prism/node.rb#4104
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4185
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4111
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4116
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4126
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4121
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> ClassVariableReadNode
#
# source://prism//lib/prism/node.rb#4131
sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableReadNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4116
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#4139
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4151
sig { override.returns(String) }
def inspect; end
# The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# @@abc # name `:@@abc`
#
# @@_test # name `:@@_test`
#
# source://prism//lib/prism/node.rb#4148
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4169
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4179
def type; end
end
end
# Represents writing to a class variable in a context that doesn't have an explicit value.
#
# @@foo, @@bar = baz
# ^^^^^ ^^^^^
#
# source://prism//lib/prism/node.rb#4195
class Prism::ClassVariableTargetNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode
#
# source://prism//lib/prism/node.rb#4197
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4274
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4204
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4209
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4219
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4214
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> ClassVariableTargetNode
#
# source://prism//lib/prism/node.rb#4224
sig { params(name: Symbol, location: Prism::Location).returns(Prism::ClassVariableTargetNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4209
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#4232
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4240
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#4237
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4258
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4268
def type; end
end
end
# Represents writing to a class variable.
#
# @@foo = 1
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#4284
class Prism::ClassVariableWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
#
# @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode
#
# source://prism//lib/prism/node.rb#4286
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4404
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4296
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4301
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4311
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4306
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ClassVariableWriteNode
#
# source://prism//lib/prism/node.rb#4316
sig do
params(
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ClassVariableWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4301
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#4324
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4370
sig { override.returns(String) }
def inspect; end
# The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# @@abc = 123 # name `@@abc`
#
# @@_test = :test # name `@@_test`
#
# source://prism//lib/prism/node.rb#4333
sig { returns(Symbol) }
def name; end
# The location of the variable name.
#
# @@foo = :bar
# ^^^^^
#
# source://prism//lib/prism/node.rb#4339
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#4365
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# @@foo = :bar
# ^
#
# source://prism//lib/prism/node.rb#4358
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4388
sig { override.returns(Symbol) }
def type; end
# The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# @@foo = :bar
# ^^^^
#
# @@_xyz = 123
# ^^^
#
# source://prism//lib/prism/node.rb#4352
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4398
def type; end
end
end
# This represents a comment that was encountered during parsing. It is the
# base class for all comment types.
#
# source://prism//lib/prism/parse_result.rb#366
class Prism::Comment
abstract!
# Create a new comment object with the given location.
#
# @return [Comment] a new instance of Comment
#
# source://prism//lib/prism/parse_result.rb#371
sig { params(location: Prism::Location).void }
def initialize(location); end
# Implement the hash pattern matching interface for Comment.
#
# source://prism//lib/prism/parse_result.rb#376
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The location of this comment in the source.
#
# source://prism//lib/prism/parse_result.rb#368
sig { returns(Prism::Location) }
def location; end
# Returns the content of the comment by slicing it from the source code.
#
# source://prism//lib/prism/parse_result.rb#381
sig { returns(String) }
def slice; end
sig { abstract.returns(T::Boolean) }
def trailing?; end
end
# A compiler is a visitor that returns the value of each node as it visits.
# This is as opposed to a visitor which will only walk the tree. This can be
# useful when you are trying to compile a tree into a different format.
#
# For example, to build a representation of the tree as s-expressions, you
# could write:
#
# class SExpressions < Prism::Compiler
# def visit_arguments_node(node) = [:arguments, super]
# def visit_call_node(node) = [:call, super]
# def visit_integer_node(node) = [:integer]
# def visit_program_node(node) = [:program, super]
# end
#
# Prism.parse("1 + 2").value.accept(SExpressions.new)
# # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]
#
# source://prism//lib/prism/compiler.rb#27
class Prism::Compiler < ::Prism::Visitor
# Visit an individual node.
#
# source://prism//lib/prism/compiler.rb#29
sig { params(node: T.nilable(Prism::Node)).returns(T.untyped) }
def visit(node); end
# Visit the child nodes of the given node.
# Compile a AliasGlobalVariableNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_alias_global_variable_node(node); end
# Visit the child nodes of the given node.
# Compile a AliasMethodNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_alias_method_node(node); end
# Visit a list of nodes.
#
# source://prism//lib/prism/compiler.rb#34
sig { params(nodes: T::Array[T.nilable(Prism::Node)]).returns(T::Array[T.untyped]) }
def visit_all(nodes); end
# Visit the child nodes of the given node.
# Compile a AlternationPatternNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_alternation_pattern_node(node); end
# Visit the child nodes of the given node.
# Compile a AndNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_and_node(node); end
# Visit the child nodes of the given node.
# Compile a ArgumentsNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_arguments_node(node); end
# Visit the child nodes of the given node.
# Compile a ArrayNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_array_node(node); end
# Visit the child nodes of the given node.
# Compile a ArrayPatternNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_array_pattern_node(node); end
# Visit the child nodes of the given node.
# Compile a AssocNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_assoc_node(node); end
# Visit the child nodes of the given node.
# Compile a AssocSplatNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_assoc_splat_node(node); end
# Visit the child nodes of the given node.
# Compile a BackReferenceReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_back_reference_read_node(node); end
# Visit the child nodes of the given node.
# Compile a BeginNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_begin_node(node); end
# Visit the child nodes of the given node.
# Compile a BlockArgumentNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_block_argument_node(node); end
# Visit the child nodes of the given node.
# Compile a BlockLocalVariableNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_block_local_variable_node(node); end
# Visit the child nodes of the given node.
# Compile a BlockNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_block_node(node); end
# Visit the child nodes of the given node.
# Compile a BlockParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_block_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a BlockParametersNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_block_parameters_node(node); end
# Visit the child nodes of the given node.
# Compile a BreakNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_break_node(node); end
# Visit the child nodes of the given node.
# Compile a CallAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_call_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a CallNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_call_node(node); end
# Visit the child nodes of the given node.
# Compile a CallOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_call_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a CallOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_call_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a CallTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_call_target_node(node); end
# Visit the child nodes of the given node.
# Compile a CapturePatternNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_capture_pattern_node(node); end
# Visit the child nodes of the given node.
# Compile a CaseMatchNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_case_match_node(node); end
# Visit the child nodes of the given node.
# Compile a CaseNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_case_node(node); end
# Visit the child nodes of the given node.
#
# source://prism//lib/prism/compiler.rb#39
sig { params(node: Prism::Node).returns(T::Array[T.untyped]) }
def visit_child_nodes(node); end
# Visit the child nodes of the given node.
# Compile a ClassNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_read_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_target_node(node); end
# Visit the child nodes of the given node.
# Compile a ClassVariableWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_class_variable_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_target_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantPathWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_path_write_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_read_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_target_node(node); end
# Visit the child nodes of the given node.
# Compile a ConstantWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_constant_write_node(node); end
# Visit the child nodes of the given node.
# Compile a DefNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_def_node(node); end
# Visit the child nodes of the given node.
# Compile a DefinedNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_defined_node(node); end
# Visit the child nodes of the given node.
# Compile a ElseNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_else_node(node); end
# Visit the child nodes of the given node.
# Compile a EmbeddedStatementsNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_embedded_statements_node(node); end
# Visit the child nodes of the given node.
# Compile a EmbeddedVariableNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_embedded_variable_node(node); end
# Visit the child nodes of the given node.
# Compile a EnsureNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_ensure_node(node); end
# Visit the child nodes of the given node.
# Compile a FalseNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_false_node(node); end
# Visit the child nodes of the given node.
# Compile a FindPatternNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_find_pattern_node(node); end
# Visit the child nodes of the given node.
# Compile a FlipFlopNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_flip_flop_node(node); end
# Visit the child nodes of the given node.
# Compile a FloatNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_float_node(node); end
# Visit the child nodes of the given node.
# Compile a ForNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_for_node(node); end
# Visit the child nodes of the given node.
# Compile a ForwardingArgumentsNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_forwarding_arguments_node(node); end
# Visit the child nodes of the given node.
# Compile a ForwardingParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_forwarding_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a ForwardingSuperNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_forwarding_super_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_read_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_target_node(node); end
# Visit the child nodes of the given node.
# Compile a GlobalVariableWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_global_variable_write_node(node); end
# Visit the child nodes of the given node.
# Compile a HashNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_hash_node(node); end
# Visit the child nodes of the given node.
# Compile a HashPatternNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_hash_pattern_node(node); end
# Visit the child nodes of the given node.
# Compile a IfNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_if_node(node); end
# Visit the child nodes of the given node.
# Compile a ImaginaryNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_imaginary_node(node); end
# Visit the child nodes of the given node.
# Compile a ImplicitNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_implicit_node(node); end
# Visit the child nodes of the given node.
# Compile a ImplicitRestNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_implicit_rest_node(node); end
# Visit the child nodes of the given node.
# Compile a InNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_in_node(node); end
# Visit the child nodes of the given node.
# Compile a IndexAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_index_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a IndexOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_index_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a IndexOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_index_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a IndexTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_index_target_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_read_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_target_node(node); end
# Visit the child nodes of the given node.
# Compile a InstanceVariableWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_instance_variable_write_node(node); end
# Visit the child nodes of the given node.
# Compile a IntegerNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_integer_node(node); end
# Visit the child nodes of the given node.
# Compile a InterpolatedMatchLastLineNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_interpolated_match_last_line_node(node); end
# Visit the child nodes of the given node.
# Compile a InterpolatedRegularExpressionNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_interpolated_regular_expression_node(node); end
# Visit the child nodes of the given node.
# Compile a InterpolatedStringNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_interpolated_string_node(node); end
# Visit the child nodes of the given node.
# Compile a InterpolatedSymbolNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_interpolated_symbol_node(node); end
# Visit the child nodes of the given node.
# Compile a InterpolatedXStringNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_interpolated_x_string_node(node); end
# Visit the child nodes of the given node.
# Compile a ItLocalVariableReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_it_local_variable_read_node(node); end
# Visit the child nodes of the given node.
# Compile a ItParametersNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_it_parameters_node(node); end
# Visit the child nodes of the given node.
# Compile a KeywordHashNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_keyword_hash_node(node); end
# Visit the child nodes of the given node.
# Compile a KeywordRestParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_keyword_rest_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a LambdaNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_lambda_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableAndWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_and_write_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableOperatorWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_operator_write_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableOrWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_or_write_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_read_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_target_node(node); end
# Visit the child nodes of the given node.
# Compile a LocalVariableWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_local_variable_write_node(node); end
# Visit the child nodes of the given node.
# Compile a MatchLastLineNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_match_last_line_node(node); end
# Visit the child nodes of the given node.
# Compile a MatchPredicateNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_match_predicate_node(node); end
# Visit the child nodes of the given node.
# Compile a MatchRequiredNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_match_required_node(node); end
# Visit the child nodes of the given node.
# Compile a MatchWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_match_write_node(node); end
# Visit the child nodes of the given node.
# Compile a MissingNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_missing_node(node); end
# Visit the child nodes of the given node.
# Compile a ModuleNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_module_node(node); end
# Visit the child nodes of the given node.
# Compile a MultiTargetNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_multi_target_node(node); end
# Visit the child nodes of the given node.
# Compile a MultiWriteNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_multi_write_node(node); end
# Visit the child nodes of the given node.
# Compile a NextNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_next_node(node); end
# Visit the child nodes of the given node.
# Compile a NilNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_nil_node(node); end
# Visit the child nodes of the given node.
# Compile a NoKeywordsParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_no_keywords_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a NumberedParametersNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_numbered_parameters_node(node); end
# Visit the child nodes of the given node.
# Compile a NumberedReferenceReadNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_numbered_reference_read_node(node); end
# Visit the child nodes of the given node.
# Compile a OptionalKeywordParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_optional_keyword_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a OptionalParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_optional_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a OrNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_or_node(node); end
# Visit the child nodes of the given node.
# Compile a ParametersNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_parameters_node(node); end
# Visit the child nodes of the given node.
# Compile a ParenthesesNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_parentheses_node(node); end
# Visit the child nodes of the given node.
# Compile a PinnedExpressionNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_pinned_expression_node(node); end
# Visit the child nodes of the given node.
# Compile a PinnedVariableNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_pinned_variable_node(node); end
# Visit the child nodes of the given node.
# Compile a PostExecutionNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_post_execution_node(node); end
# Visit the child nodes of the given node.
# Compile a PreExecutionNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_pre_execution_node(node); end
# Visit the child nodes of the given node.
# Compile a ProgramNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_program_node(node); end
# Visit the child nodes of the given node.
# Compile a RangeNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_range_node(node); end
# Visit the child nodes of the given node.
# Compile a RationalNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_rational_node(node); end
# Visit the child nodes of the given node.
# Compile a RedoNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_redo_node(node); end
# Visit the child nodes of the given node.
# Compile a RegularExpressionNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_regular_expression_node(node); end
# Visit the child nodes of the given node.
# Compile a RequiredKeywordParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_required_keyword_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a RequiredParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_required_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a RescueModifierNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_rescue_modifier_node(node); end
# Visit the child nodes of the given node.
# Compile a RescueNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_rescue_node(node); end
# Visit the child nodes of the given node.
# Compile a RestParameterNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_rest_parameter_node(node); end
# Visit the child nodes of the given node.
# Compile a RetryNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_retry_node(node); end
# Visit the child nodes of the given node.
# Compile a ReturnNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_return_node(node); end
# Visit the child nodes of the given node.
# Compile a SelfNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_self_node(node); end
# Visit the child nodes of the given node.
# Compile a ShareableConstantNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_shareable_constant_node(node); end
# Visit the child nodes of the given node.
# Compile a SingletonClassNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_singleton_class_node(node); end
# Visit the child nodes of the given node.
# Compile a SourceEncodingNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_source_encoding_node(node); end
# Visit the child nodes of the given node.
# Compile a SourceFileNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_source_file_node(node); end
# Visit the child nodes of the given node.
# Compile a SourceLineNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_source_line_node(node); end
# Visit the child nodes of the given node.
# Compile a SplatNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_splat_node(node); end
# Visit the child nodes of the given node.
# Compile a StatementsNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_statements_node(node); end
# Visit the child nodes of the given node.
# Compile a StringNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_string_node(node); end
# Visit the child nodes of the given node.
# Compile a SuperNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_super_node(node); end
# Visit the child nodes of the given node.
# Compile a SymbolNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_symbol_node(node); end
# Visit the child nodes of the given node.
# Compile a TrueNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_true_node(node); end
# Visit the child nodes of the given node.
# Compile a UndefNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_undef_node(node); end
# Visit the child nodes of the given node.
# Compile a UnlessNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_unless_node(node); end
# Visit the child nodes of the given node.
# Compile a UntilNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_until_node(node); end
# Visit the child nodes of the given node.
# Compile a WhenNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_when_node(node); end
# Visit the child nodes of the given node.
# Compile a WhileNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_while_node(node); end
# Visit the child nodes of the given node.
# Compile a XStringNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_x_string_node(node); end
# Visit the child nodes of the given node.
# Compile a YieldNode node
#
# source://prism//lib/prism/compiler.rb#39
def visit_yield_node(node); end
end
# Represents the use of the `&&=` operator for assignment to a constant.
#
# Target &&= value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#4417
class Prism::ConstantAndWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode
#
# source://prism//lib/prism/node.rb#4419
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4521
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4429
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4434
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4444
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4439
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantAndWriteNode
#
# source://prism//lib/prism/node.rb#4449
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ConstantAndWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4434
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#4457
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#145
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4487
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#4462
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#4465
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#4482
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#4472
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4505
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#4479
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4515
def type; end
end
end
# Represents assigning to a constant using an operator that isn't `=`.
#
# Target += value
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#4534
class Prism::ConstantOperatorWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
#
# @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode
#
# source://prism//lib/prism/node.rb#4536
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4637
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4547
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#4600
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#4590
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4552
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4562
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4557
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
#
# source://prism//lib/prism/node.rb#4567
sig do
params(
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).returns(Prism::ConstantOperatorWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4552
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#4575
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#157
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4603
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#4580
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#4583
sig { returns(Prism::Location) }
def name_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#355
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#362
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4621
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#4597
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4631
def type; end
end
end
# Represents the use of the `||=` operator for assignment to a constant.
#
# Target ||= value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#4651
class Prism::ConstantOrWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode
#
# source://prism//lib/prism/node.rb#4653
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4755
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4663
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4668
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4678
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4673
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantOrWriteNode
#
# source://prism//lib/prism/node.rb#4683
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ConstantOrWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4668
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#4691
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#151
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4721
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#4696
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#4699
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#4716
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#4706
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4739
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#4713
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4749
def type; end
end
end
# Represents the use of the `&&=` operator for assignment to a constant path.
#
# Parent::Child &&= value
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#4768
class Prism::ConstantPathAndWriteNode < ::Prism::Node
# def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode
#
# source://prism//lib/prism/node.rb#4770
sig do
params(
source: Prism::Source,
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, target, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#4864
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4779
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4784
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4794
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4789
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathAndWriteNode
#
# source://prism//lib/prism/node.rb#4799
sig do
params(
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ConstantPathAndWriteNode)
end
def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4784
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#4807
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4830
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#4825
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#4815
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader target: ConstantPathNode
#
# source://prism//lib/prism/node.rb#4812
sig { returns(Prism::ConstantPathNode) }
def target; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4848
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#4822
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4858
def type; end
end
end
# Represents accessing a constant through a path of `::` operators.
#
# Foo::Bar
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#4876
class Prism::ConstantPathNode < ::Prism::Node
# def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
#
# @return [ConstantPathNode] a new instance of ConstantPathNode
#
# source://prism//lib/prism/node.rb#4878
sig do
params(
source: Prism::Source,
parent: T.nilable(Prism::Node),
name: T.nilable(Symbol),
delimiter_loc: Prism::Location,
name_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, parent, name, delimiter_loc, name_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5003
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#4888
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# Previously, we had a child node on this class that contained either a
# constant read or a missing node. To not cause a breaking change, we
# continue to supply that API.
#
# source://prism//lib/prism/node_ext.rb#196
def child; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4893
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#4905
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#4898
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathNode
#
# source://prism//lib/prism/node.rb#4910
sig do
params(
parent: T.nilable(Prism::Node),
name: T.nilable(Symbol),
delimiter_loc: Prism::Location,
name_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ConstantPathNode)
end
def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#4893
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#4918
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def delimiter: () -> String
#
# source://prism//lib/prism/node.rb#4964
sig { returns(String) }
def delimiter; end
# The location of the `::` delimiter.
#
# ::Foo
# ^^
#
# One::Two
# ^^
#
# source://prism//lib/prism/node.rb#4944
sig { returns(Prism::Location) }
def delimiter_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns the full name of this constant path. For example: "Foo::Bar"
#
# source://prism//lib/prism/node_ext.rb#189
sig { returns(String) }
def full_name; end
# Returns the list of parts for the full name of this constant path.
# For example: [:Foo, :Bar]
#
# source://prism//lib/prism/node_ext.rb#167
sig { returns(T::Array[Symbol]) }
def full_name_parts; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#4969
sig { override.returns(String) }
def inspect; end
# The name of the constant being accessed. This could be `nil` in the event of a syntax error.
#
# source://prism//lib/prism/node.rb#4935
sig { returns(T.nilable(Symbol)) }
def name; end
# The location of the name of the constant.
#
# ::Foo
# ^^^
#
# One::Two
# ^^^
#
# source://prism//lib/prism/node.rb#4957
sig { returns(Prism::Location) }
def name_loc; end
# The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
#
# Foo::Bar
# ^^^
#
# self::Test
# ^^^^
#
# a.b::C
# ^^^
#
# source://prism//lib/prism/node.rb#4932
sig { returns(T.nilable(Prism::Node)) }
def parent; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4987
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#4997
def type; end
end
end
# An error class raised when dynamic parts are found while computing a
# constant path's full name. For example:
# Foo::Bar::Baz -> does not raise because all parts of the constant path are
# simple constants
# var::Bar::Baz -> raises because the first part of the constant path is a
# local variable
#
# source://prism//lib/prism/node_ext.rb#158
class Prism::ConstantPathNode::DynamicPartsInConstantPathError < ::StandardError; end
# An error class raised when missing nodes are found while computing a
# constant path's full name. For example:
# Foo:: -> raises because the constant path is missing the last part
#
# source://prism//lib/prism/node_ext.rb#163
class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError; end
# Represents assigning to a constant path using an operator that isn't `=`.
#
# Parent::Child += value
# ^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#5016
class Prism::ConstantPathOperatorWriteNode < ::Prism::Node
# def initialize: (ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
#
# @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode
#
# source://prism//lib/prism/node.rb#5018
sig do
params(
source: Prism::Source,
target: Prism::ConstantPathNode,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).void
end
def initialize(source, target, binary_operator_loc, value, binary_operator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5111
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5028
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#5074
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#5064
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5033
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5043
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5038
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
#
# source://prism//lib/prism/node.rb#5048
sig do
params(
target: Prism::ConstantPathNode,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).returns(Prism::ConstantPathOperatorWriteNode)
end
def copy(target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5033
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#5056
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5077
sig { override.returns(String) }
def inspect; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#371
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#378
def operator_loc; end
# attr_reader target: ConstantPathNode
#
# source://prism//lib/prism/node.rb#5061
sig { returns(Prism::ConstantPathNode) }
def target; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5095
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#5071
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5105
def type; end
end
end
# Represents the use of the `||=` operator for assignment to a constant path.
#
# Parent::Child ||= value
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#5124
class Prism::ConstantPathOrWriteNode < ::Prism::Node
# def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode
#
# source://prism//lib/prism/node.rb#5126
sig do
params(
source: Prism::Source,
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, target, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5220
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5135
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5140
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5150
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5145
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathOrWriteNode
#
# source://prism//lib/prism/node.rb#5155
sig do
params(
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ConstantPathOrWriteNode)
end
def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5140
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#5163
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5186
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#5181
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#5171
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader target: ConstantPathNode
#
# source://prism//lib/prism/node.rb#5168
sig { returns(Prism::ConstantPathNode) }
def target; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5204
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#5178
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5214
def type; end
end
end
# Represents writing to a constant path in a context that doesn't have an explicit value.
#
# Foo::Foo, Bar::Bar = baz
# ^^^^^^^^ ^^^^^^^^
#
# source://prism//lib/prism/node.rb#5232
class Prism::ConstantPathTargetNode < ::Prism::Node
# def initialize: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, Location location) -> void
#
# @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode
#
# source://prism//lib/prism/node.rb#5234
sig do
params(
source: Prism::Source,
parent: T.nilable(Prism::Node),
name: T.nilable(Symbol),
delimiter_loc: Prism::Location,
name_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, parent, name, delimiter_loc, name_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5338
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5244
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# Previously, we had a child node on this class that contained either a
# constant read or a missing node. To not cause a breaking change, we
# continue to supply that API.
#
# source://prism//lib/prism/node_ext.rb#232
def child; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5249
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5261
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5254
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location, ?location: Location) -> ConstantPathTargetNode
#
# source://prism//lib/prism/node.rb#5266
sig do
params(
parent: T.nilable(Prism::Node),
name: T.nilable(Symbol),
delimiter_loc: Prism::Location,
name_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ConstantPathTargetNode)
end
def copy(parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5249
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#5274
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def delimiter: () -> String
#
# source://prism//lib/prism/node.rb#5299
sig { returns(String) }
def delimiter; end
# attr_reader delimiter_loc: Location
#
# source://prism//lib/prism/node.rb#5285
sig { returns(Prism::Location) }
def delimiter_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns the full name of this constant path. For example: "Foo::Bar"
#
# source://prism//lib/prism/node_ext.rb#225
sig { returns(String) }
def full_name; end
# Returns the list of parts for the full name of this constant path.
# For example: [:Foo, :Bar]
#
# source://prism//lib/prism/node_ext.rb#205
sig { returns(T::Array[Symbol]) }
def full_name_parts; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5304
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol?
#
# source://prism//lib/prism/node.rb#5282
sig { returns(T.nilable(Symbol)) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#5292
sig { returns(Prism::Location) }
def name_loc; end
# attr_reader parent: Prism::node?
#
# source://prism//lib/prism/node.rb#5279
sig { returns(T.nilable(Prism::Node)) }
def parent; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5322
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5332
def type; end
end
end
# Represents writing to a constant path.
#
# ::Foo = 1
# ^^^^^^^^^
#
# Foo::Bar = 1
# ^^^^^^^^^^^^
#
# ::Foo::Bar = 1
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#5357
class Prism::ConstantPathWriteNode < ::Prism::Node
# def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode
#
# source://prism//lib/prism/node.rb#5359
sig do
params(
source: Prism::Source,
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, target, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5465
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5368
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5373
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5383
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5378
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathWriteNode
#
# source://prism//lib/prism/node.rb#5388
sig do
params(
target: Prism::ConstantPathNode,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::ConstantPathWriteNode)
end
def copy(target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5373
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#5396
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5431
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#5426
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# ::ABC = 123
# ^
#
# source://prism//lib/prism/node.rb#5413
sig { returns(Prism::Location) }
def operator_loc; end
# A node representing the constant path being written to.
#
# Foo::Bar = 1
# ^^^^^^^^
#
# ::Foo = :abc
# ^^^^^
#
# source://prism//lib/prism/node.rb#5407
sig { returns(Prism::ConstantPathNode) }
def target; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5449
sig { override.returns(Symbol) }
def type; end
# The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# FOO::BAR = :abc
# ^^^^
#
# source://prism//lib/prism/node.rb#5423
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5459
def type; end
end
end
# Represents referencing a constant.
#
# Foo
# ^^^
#
# source://prism//lib/prism/node.rb#5477
class Prism::ConstantReadNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [ConstantReadNode] a new instance of ConstantReadNode
#
# source://prism//lib/prism/node.rb#5479
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5560
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5486
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5491
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5501
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5496
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> ConstantReadNode
#
# source://prism//lib/prism/node.rb#5506
sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantReadNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5491
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#5514
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns the full name of this constant. For example: "Foo"
#
# source://prism//lib/prism/node_ext.rb#133
sig { returns(String) }
def full_name; end
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
#
# source://prism//lib/prism/node_ext.rb#128
sig { returns(T::Array[Symbol]) }
def full_name_parts; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5526
sig { override.returns(String) }
def inspect; end
# The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
#
# X # name `:X`
#
# SOME_CONSTANT # name `:SOME_CONSTANT`
#
# source://prism//lib/prism/node.rb#5523
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5544
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5554
def type; end
end
end
# Represents writing to a constant in a context that doesn't have an explicit value.
#
# Foo, Bar = baz
# ^^^ ^^^
#
# source://prism//lib/prism/node.rb#5570
class Prism::ConstantTargetNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [ConstantTargetNode] a new instance of ConstantTargetNode
#
# source://prism//lib/prism/node.rb#5572
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5649
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5579
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5584
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5594
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5589
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> ConstantTargetNode
#
# source://prism//lib/prism/node.rb#5599
sig { params(name: Symbol, location: Prism::Location).returns(Prism::ConstantTargetNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5584
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#5607
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns the full name of this constant. For example: "Foo"
#
# source://prism//lib/prism/node_ext.rb#246
sig { returns(String) }
def full_name; end
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
#
# source://prism//lib/prism/node_ext.rb#241
sig { returns(T::Array[Symbol]) }
def full_name_parts; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5615
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#5612
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5633
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5643
def type; end
end
end
# Represents writing to a constant.
#
# Foo = 1
# ^^^^^^^
#
# source://prism//lib/prism/node.rb#5659
class Prism::ConstantWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
#
# @return [ConstantWriteNode] a new instance of ConstantWriteNode
#
# source://prism//lib/prism/node.rb#5661
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#5779
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5671
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5676
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5686
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5681
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ConstantWriteNode
#
# source://prism//lib/prism/node.rb#5691
sig do
params(
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ConstantWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5676
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#5699
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns the full name of this constant. For example: "Foo"
#
# source://prism//lib/prism/node_ext.rb#146
sig { returns(String) }
def full_name; end
# Returns the list of parts for the full name of this constant.
# For example: [:Foo]
#
# source://prism//lib/prism/node_ext.rb#141
sig { returns(T::Array[Symbol]) }
def full_name_parts; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5745
sig { override.returns(String) }
def inspect; end
# The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
#
# Foo = :bar # name `:Foo`
#
# XYZ = 1 # name `:XYZ`
#
# source://prism//lib/prism/node.rb#5708
sig { returns(Symbol) }
def name; end
# The location of the constant name.
#
# FOO = 1
# ^^^
#
# source://prism//lib/prism/node.rb#5714
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#5740
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# FOO = :bar
# ^
#
# source://prism//lib/prism/node.rb#5733
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5763
sig { override.returns(Symbol) }
def type; end
# The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# FOO = :bar
# ^^^^
#
# MyClass = Class.new
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#5727
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5773
def type; end
end
end
# The DSL module provides a set of methods that can be used to create prism
# nodes in a more concise manner. For example, instead of writing:
#
# source = Prism::Source.for("[1]")
#
# Prism::ArrayNode.new(
# [
# Prism::IntegerNode.new(
# Prism::IntegerBaseFlags::DECIMAL,
# 1,
# Prism::Location.new(source, 1, 1),
# source
# )
# ],
# Prism::Location.new(source, 0, 1),
# Prism::Location.new(source, 2, 1),
# source
# )
#
# you could instead write:
#
# source = Prism::Source.for("[1]")
#
# ArrayNode(
# IntegerNode(Prism::IntegerBaseFlags::DECIMAL, 1, Location(source, 1, 1)), source),
# Location(source, 0, 1),
# Location(source, 2, 1),
# source
# )
#
# This is mostly helpful in the context of writing tests, but can also be used
# to generate trees programmatically.
#
# source://prism//lib/prism/dsl.rb#42
module Prism::DSL
private
# Create a new AliasGlobalVariableNode node
#
# source://prism//lib/prism/dsl.rb#51
def AliasGlobalVariableNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new AliasMethodNode node
#
# source://prism//lib/prism/dsl.rb#56
def AliasMethodNode(new_name, old_name, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new AlternationPatternNode node
#
# source://prism//lib/prism/dsl.rb#61
def AlternationPatternNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new AndNode node
#
# source://prism//lib/prism/dsl.rb#66
def AndNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ArgumentsNode node
#
# source://prism//lib/prism/dsl.rb#71
def ArgumentsNode(flags, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ArrayNode node
#
# source://prism//lib/prism/dsl.rb#76
def ArrayNode(flags, elements, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ArrayPatternNode node
#
# source://prism//lib/prism/dsl.rb#81
def ArrayPatternNode(constant, requireds, rest, posts, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new AssocNode node
#
# source://prism//lib/prism/dsl.rb#86
def AssocNode(key, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new AssocSplatNode node
#
# source://prism//lib/prism/dsl.rb#91
def AssocSplatNode(value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BackReferenceReadNode node
#
# source://prism//lib/prism/dsl.rb#96
def BackReferenceReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BeginNode node
#
# source://prism//lib/prism/dsl.rb#101
def BeginNode(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BlockArgumentNode node
#
# source://prism//lib/prism/dsl.rb#106
def BlockArgumentNode(expression, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BlockLocalVariableNode node
#
# source://prism//lib/prism/dsl.rb#111
def BlockLocalVariableNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BlockNode node
#
# source://prism//lib/prism/dsl.rb#116
def BlockNode(locals, parameters, body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BlockParameterNode node
#
# source://prism//lib/prism/dsl.rb#121
def BlockParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BlockParametersNode node
#
# source://prism//lib/prism/dsl.rb#126
def BlockParametersNode(parameters, locals, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new BreakNode node
#
# source://prism//lib/prism/dsl.rb#131
def BreakNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CallAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#136
def CallAndWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CallNode node
#
# source://prism//lib/prism/dsl.rb#141
def CallNode(flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CallOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#146
def CallOperatorWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CallOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#151
def CallOrWriteNode(flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CallTargetNode node
#
# source://prism//lib/prism/dsl.rb#156
def CallTargetNode(flags, receiver, call_operator_loc, name, message_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CapturePatternNode node
#
# source://prism//lib/prism/dsl.rb#161
def CapturePatternNode(value, target, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CaseMatchNode node
#
# source://prism//lib/prism/dsl.rb#166
def CaseMatchNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new CaseNode node
#
# source://prism//lib/prism/dsl.rb#171
def CaseNode(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassNode node
#
# source://prism//lib/prism/dsl.rb#176
def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#181
def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#186
def ClassVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#191
def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableReadNode node
#
# source://prism//lib/prism/dsl.rb#196
def ClassVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableTargetNode node
#
# source://prism//lib/prism/dsl.rb#201
def ClassVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ClassVariableWriteNode node
#
# source://prism//lib/prism/dsl.rb#206
def ClassVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#211
def ConstantAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#216
def ConstantOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#221
def ConstantOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#226
def ConstantPathAndWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathNode node
#
# source://prism//lib/prism/dsl.rb#231
def ConstantPathNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#236
def ConstantPathOperatorWriteNode(target, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#241
def ConstantPathOrWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathTargetNode node
#
# source://prism//lib/prism/dsl.rb#246
def ConstantPathTargetNode(parent, name, delimiter_loc, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantPathWriteNode node
#
# source://prism//lib/prism/dsl.rb#251
def ConstantPathWriteNode(target, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantReadNode node
#
# source://prism//lib/prism/dsl.rb#256
def ConstantReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantTargetNode node
#
# source://prism//lib/prism/dsl.rb#261
def ConstantTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ConstantWriteNode node
#
# source://prism//lib/prism/dsl.rb#266
def ConstantWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new DefNode node
#
# source://prism//lib/prism/dsl.rb#271
def DefNode(name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new DefinedNode node
#
# source://prism//lib/prism/dsl.rb#276
def DefinedNode(lparen_loc, value, rparen_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ElseNode node
#
# source://prism//lib/prism/dsl.rb#281
def ElseNode(else_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new EmbeddedStatementsNode node
#
# source://prism//lib/prism/dsl.rb#286
def EmbeddedStatementsNode(opening_loc, statements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new EmbeddedVariableNode node
#
# source://prism//lib/prism/dsl.rb#291
def EmbeddedVariableNode(operator_loc, variable, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new EnsureNode node
#
# source://prism//lib/prism/dsl.rb#296
def EnsureNode(ensure_keyword_loc, statements, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new FalseNode node
#
# source://prism//lib/prism/dsl.rb#301
def FalseNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new FindPatternNode node
#
# source://prism//lib/prism/dsl.rb#306
def FindPatternNode(constant, left, requireds, right, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new FlipFlopNode node
#
# source://prism//lib/prism/dsl.rb#311
def FlipFlopNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new FloatNode node
#
# source://prism//lib/prism/dsl.rb#316
def FloatNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ForNode node
#
# source://prism//lib/prism/dsl.rb#321
def ForNode(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ForwardingArgumentsNode node
#
# source://prism//lib/prism/dsl.rb#326
def ForwardingArgumentsNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ForwardingParameterNode node
#
# source://prism//lib/prism/dsl.rb#331
def ForwardingParameterNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ForwardingSuperNode node
#
# source://prism//lib/prism/dsl.rb#336
def ForwardingSuperNode(block, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#341
def GlobalVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#346
def GlobalVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#351
def GlobalVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableReadNode node
#
# source://prism//lib/prism/dsl.rb#356
def GlobalVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableTargetNode node
#
# source://prism//lib/prism/dsl.rb#361
def GlobalVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new GlobalVariableWriteNode node
#
# source://prism//lib/prism/dsl.rb#366
def GlobalVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new HashNode node
#
# source://prism//lib/prism/dsl.rb#371
def HashNode(opening_loc, elements, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new HashPatternNode node
#
# source://prism//lib/prism/dsl.rb#376
def HashPatternNode(constant, elements, rest, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IfNode node
#
# source://prism//lib/prism/dsl.rb#381
def IfNode(if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ImaginaryNode node
#
# source://prism//lib/prism/dsl.rb#386
def ImaginaryNode(numeric, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ImplicitNode node
#
# source://prism//lib/prism/dsl.rb#391
def ImplicitNode(value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ImplicitRestNode node
#
# source://prism//lib/prism/dsl.rb#396
def ImplicitRestNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InNode node
#
# source://prism//lib/prism/dsl.rb#401
def InNode(pattern, statements, in_loc, then_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IndexAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#406
def IndexAndWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IndexOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#411
def IndexOperatorWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IndexOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#416
def IndexOrWriteNode(flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IndexTargetNode node
#
# source://prism//lib/prism/dsl.rb#421
def IndexTargetNode(flags, receiver, opening_loc, arguments, closing_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#426
def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#431
def InstanceVariableOperatorWriteNode(name, name_loc, binary_operator_loc, value, binary_operator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#436
def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableReadNode node
#
# source://prism//lib/prism/dsl.rb#441
def InstanceVariableReadNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableTargetNode node
#
# source://prism//lib/prism/dsl.rb#446
def InstanceVariableTargetNode(name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InstanceVariableWriteNode node
#
# source://prism//lib/prism/dsl.rb#451
def InstanceVariableWriteNode(name, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new IntegerNode node
#
# source://prism//lib/prism/dsl.rb#456
def IntegerNode(flags, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InterpolatedMatchLastLineNode node
#
# source://prism//lib/prism/dsl.rb#461
def InterpolatedMatchLastLineNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InterpolatedRegularExpressionNode node
#
# source://prism//lib/prism/dsl.rb#466
def InterpolatedRegularExpressionNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InterpolatedStringNode node
#
# source://prism//lib/prism/dsl.rb#471
def InterpolatedStringNode(flags, opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InterpolatedSymbolNode node
#
# source://prism//lib/prism/dsl.rb#476
def InterpolatedSymbolNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new InterpolatedXStringNode node
#
# source://prism//lib/prism/dsl.rb#481
def InterpolatedXStringNode(opening_loc, parts, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ItLocalVariableReadNode node
#
# source://prism//lib/prism/dsl.rb#486
def ItLocalVariableReadNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ItParametersNode node
#
# source://prism//lib/prism/dsl.rb#491
def ItParametersNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new KeywordHashNode node
#
# source://prism//lib/prism/dsl.rb#496
def KeywordHashNode(flags, elements, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new KeywordRestParameterNode node
#
# source://prism//lib/prism/dsl.rb#501
def KeywordRestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LambdaNode node
#
# source://prism//lib/prism/dsl.rb#506
def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableAndWriteNode node
#
# source://prism//lib/prism/dsl.rb#511
def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableOperatorWriteNode node
#
# source://prism//lib/prism/dsl.rb#516
def LocalVariableOperatorWriteNode(name_loc, binary_operator_loc, value, name, binary_operator, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableOrWriteNode node
#
# source://prism//lib/prism/dsl.rb#521
def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableReadNode node
#
# source://prism//lib/prism/dsl.rb#526
def LocalVariableReadNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableTargetNode node
#
# source://prism//lib/prism/dsl.rb#531
def LocalVariableTargetNode(name, depth, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new LocalVariableWriteNode node
#
# source://prism//lib/prism/dsl.rb#536
def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new Location object
#
# source://prism//lib/prism/dsl.rb#46
def Location(source = T.unsafe(nil), start_offset = T.unsafe(nil), length = T.unsafe(nil)); end
# Create a new MatchLastLineNode node
#
# source://prism//lib/prism/dsl.rb#541
def MatchLastLineNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MatchPredicateNode node
#
# source://prism//lib/prism/dsl.rb#546
def MatchPredicateNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MatchRequiredNode node
#
# source://prism//lib/prism/dsl.rb#551
def MatchRequiredNode(value, pattern, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MatchWriteNode node
#
# source://prism//lib/prism/dsl.rb#556
def MatchWriteNode(call, targets, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MissingNode node
#
# source://prism//lib/prism/dsl.rb#561
def MissingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ModuleNode node
#
# source://prism//lib/prism/dsl.rb#566
def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MultiTargetNode node
#
# source://prism//lib/prism/dsl.rb#571
def MultiTargetNode(lefts, rest, rights, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new MultiWriteNode node
#
# source://prism//lib/prism/dsl.rb#576
def MultiWriteNode(lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new NextNode node
#
# source://prism//lib/prism/dsl.rb#581
def NextNode(arguments, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new NilNode node
#
# source://prism//lib/prism/dsl.rb#586
def NilNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new NoKeywordsParameterNode node
#
# source://prism//lib/prism/dsl.rb#591
def NoKeywordsParameterNode(operator_loc, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new NumberedParametersNode node
#
# source://prism//lib/prism/dsl.rb#596
def NumberedParametersNode(maximum, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new NumberedReferenceReadNode node
#
# source://prism//lib/prism/dsl.rb#601
def NumberedReferenceReadNode(number, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new OptionalKeywordParameterNode node
#
# source://prism//lib/prism/dsl.rb#606
def OptionalKeywordParameterNode(flags, name, name_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new OptionalParameterNode node
#
# source://prism//lib/prism/dsl.rb#611
def OptionalParameterNode(flags, name, name_loc, operator_loc, value, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new OrNode node
#
# source://prism//lib/prism/dsl.rb#616
def OrNode(left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ParametersNode node
#
# source://prism//lib/prism/dsl.rb#621
def ParametersNode(requireds, optionals, rest, posts, keywords, keyword_rest, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ParenthesesNode node
#
# source://prism//lib/prism/dsl.rb#626
def ParenthesesNode(body, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new PinnedExpressionNode node
#
# source://prism//lib/prism/dsl.rb#631
def PinnedExpressionNode(expression, operator_loc, lparen_loc, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new PinnedVariableNode node
#
# source://prism//lib/prism/dsl.rb#636
def PinnedVariableNode(variable, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new PostExecutionNode node
#
# source://prism//lib/prism/dsl.rb#641
def PostExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new PreExecutionNode node
#
# source://prism//lib/prism/dsl.rb#646
def PreExecutionNode(statements, keyword_loc, opening_loc, closing_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ProgramNode node
#
# source://prism//lib/prism/dsl.rb#651
def ProgramNode(locals, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RangeNode node
#
# source://prism//lib/prism/dsl.rb#656
def RangeNode(flags, left, right, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RationalNode node
#
# source://prism//lib/prism/dsl.rb#661
def RationalNode(flags, numerator, denominator, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RedoNode node
#
# source://prism//lib/prism/dsl.rb#666
def RedoNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RegularExpressionNode node
#
# source://prism//lib/prism/dsl.rb#671
def RegularExpressionNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RequiredKeywordParameterNode node
#
# source://prism//lib/prism/dsl.rb#676
def RequiredKeywordParameterNode(flags, name, name_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RequiredParameterNode node
#
# source://prism//lib/prism/dsl.rb#681
def RequiredParameterNode(flags, name, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RescueModifierNode node
#
# source://prism//lib/prism/dsl.rb#686
def RescueModifierNode(expression, keyword_loc, rescue_expression, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RescueNode node
#
# source://prism//lib/prism/dsl.rb#691
def RescueNode(keyword_loc, exceptions, operator_loc, reference, statements, consequent, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RestParameterNode node
#
# source://prism//lib/prism/dsl.rb#696
def RestParameterNode(flags, name, name_loc, operator_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new RetryNode node
#
# source://prism//lib/prism/dsl.rb#701
def RetryNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ReturnNode node
#
# source://prism//lib/prism/dsl.rb#706
def ReturnNode(flags, keyword_loc, arguments, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SelfNode node
#
# source://prism//lib/prism/dsl.rb#711
def SelfNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new ShareableConstantNode node
#
# source://prism//lib/prism/dsl.rb#716
def ShareableConstantNode(flags, write, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SingletonClassNode node
#
# source://prism//lib/prism/dsl.rb#721
def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SourceEncodingNode node
#
# source://prism//lib/prism/dsl.rb#726
def SourceEncodingNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SourceFileNode node
#
# source://prism//lib/prism/dsl.rb#731
def SourceFileNode(flags, filepath, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SourceLineNode node
#
# source://prism//lib/prism/dsl.rb#736
def SourceLineNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SplatNode node
#
# source://prism//lib/prism/dsl.rb#741
def SplatNode(operator_loc, expression, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new StatementsNode node
#
# source://prism//lib/prism/dsl.rb#746
def StatementsNode(body, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new StringNode node
#
# source://prism//lib/prism/dsl.rb#751
def StringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SuperNode node
#
# source://prism//lib/prism/dsl.rb#756
def SuperNode(keyword_loc, lparen_loc, arguments, rparen_loc, block, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new SymbolNode node
#
# source://prism//lib/prism/dsl.rb#761
def SymbolNode(flags, opening_loc, value_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new TrueNode node
#
# source://prism//lib/prism/dsl.rb#766
def TrueNode(source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new UndefNode node
#
# source://prism//lib/prism/dsl.rb#771
def UndefNode(names, keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new UnlessNode node
#
# source://prism//lib/prism/dsl.rb#776
def UnlessNode(keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new UntilNode node
#
# source://prism//lib/prism/dsl.rb#781
def UntilNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new WhenNode node
#
# source://prism//lib/prism/dsl.rb#786
def WhenNode(keyword_loc, conditions, then_keyword_loc, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new WhileNode node
#
# source://prism//lib/prism/dsl.rb#791
def WhileNode(flags, keyword_loc, closing_loc, predicate, statements, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new XStringNode node
#
# source://prism//lib/prism/dsl.rb#796
def XStringNode(flags, opening_loc, content_loc, closing_loc, unescaped, source = T.unsafe(nil), location = T.unsafe(nil)); end
# Create a new YieldNode node
#
# source://prism//lib/prism/dsl.rb#801
def YieldNode(keyword_loc, lparen_loc, arguments, rparen_loc, source = T.unsafe(nil), location = T.unsafe(nil)); end
end
# Represents a method definition.
#
# def method
# end
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#5793
class Prism::DefNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Prism::node? receiver, ParametersNode? parameters, Prism::node? body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc, Location location) -> void
#
# @return [DefNode] a new instance of DefNode
#
# source://prism//lib/prism/node.rb#5795
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
receiver: T.nilable(Prism::Node),
parameters: T.nilable(Prism::ParametersNode),
body: T.nilable(Prism::Node),
locals: T::Array[Symbol],
def_keyword_loc: Prism::Location,
operator_loc: T.nilable(Prism::Location),
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
equal_loc: T.nilable(Prism::Location),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6008
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#5813
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#5866
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5818
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#5832
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#5823
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: Prism::node?, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?, ?location: Location) -> DefNode
#
# source://prism//lib/prism/node.rb#5837
sig do
params(
name: Symbol,
name_loc: Prism::Location,
receiver: T.nilable(Prism::Node),
parameters: T.nilable(Prism::ParametersNode),
body: T.nilable(Prism::Node),
locals: T::Array[Symbol],
def_keyword_loc: Prism::Location,
operator_loc: T.nilable(Prism::Location),
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
equal_loc: T.nilable(Prism::Location),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::DefNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#5818
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: Prism::node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#5845
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def def_keyword: () -> String
#
# source://prism//lib/prism/node.rb#5944
sig { returns(String) }
def def_keyword; end
# attr_reader def_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#5872
sig { returns(Prism::Location) }
def def_keyword_loc; end
# def end_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#5969
sig { returns(T.nilable(String)) }
def end_keyword; end
# attr_reader end_keyword_loc: Location?
#
# source://prism//lib/prism/node.rb#5931
sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end
# def equal: () -> String?
#
# source://prism//lib/prism/node.rb#5964
sig { returns(T.nilable(String)) }
def equal; end
# attr_reader equal_loc: Location?
#
# source://prism//lib/prism/node.rb#5918
sig { returns(T.nilable(Prism::Location)) }
def equal_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#5974
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#5869
sig { returns(T::Array[Symbol]) }
def locals; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#5954
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#5892
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#5850
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#5853
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String?
#
# source://prism//lib/prism/node.rb#5949
sig { returns(T.nilable(String)) }
def operator; end
# attr_reader operator_loc: Location?
#
# source://prism//lib/prism/node.rb#5879
sig { returns(T.nilable(Prism::Location)) }
def operator_loc; end
# attr_reader parameters: ParametersNode?
#
# source://prism//lib/prism/node.rb#5863
sig { returns(T.nilable(Prism::ParametersNode)) }
def parameters; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#5860
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#5959
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#5905
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#5992
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6002
def type; end
end
end
# Represents the use of the `defined?` keyword.
#
# defined?(a)
# ^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#6030
class Prism::DefinedNode < ::Prism::Node
# def initialize: (Location? lparen_loc, Prism::node value, Location? rparen_loc, Location keyword_loc, Location location) -> void
#
# @return [DefinedNode] a new instance of DefinedNode
#
# source://prism//lib/prism/node.rb#6032
sig do
params(
source: Prism::Source,
lparen_loc: T.nilable(Prism::Location),
value: Prism::Node,
rparen_loc: T.nilable(Prism::Location),
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, lparen_loc, value, rparen_loc, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6160
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6042
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6047
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6057
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6052
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location, ?location: Location) -> DefinedNode
#
# source://prism//lib/prism/node.rb#6062
sig do
params(
lparen_loc: T.nilable(Prism::Location),
value: Prism::Node,
rparen_loc: T.nilable(Prism::Location),
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::DefinedNode)
end
def copy(lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6047
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#6070
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6126
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#6121
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#6104
sig { returns(Prism::Location) }
def keyword_loc; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#6111
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#6075
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#6116
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#6091
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6144
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#6088
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6154
def type; end
end
end
# source://prism//lib/prism/desugar_compiler.rb#4
class Prism::DesugarAndWriteNode
# @return [DesugarAndWriteNode] a new instance of DesugarAndWriteNode
#
# source://prism//lib/prism/desugar_compiler.rb#7
def initialize(node, source, read_class, write_class, *arguments); end
# Returns the value of attribute arguments.
#
# source://prism//lib/prism/desugar_compiler.rb#5
def arguments; end
# Desugar `x &&= y` to `x && x = y`
#
# source://prism//lib/prism/desugar_compiler.rb#16
def compile; end
# Returns the value of attribute node.
#
# source://prism//lib/prism/desugar_compiler.rb#5
def node; end
# Returns the value of attribute read_class.
#
# source://prism//lib/prism/desugar_compiler.rb#5
def read_class; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/desugar_compiler.rb#5
def source; end
# Returns the value of attribute write_class.
#
# source://prism//lib/prism/desugar_compiler.rb#5
def write_class; end
end
# DesugarCompiler is a compiler that desugars Ruby code into a more primitive
# form. This is useful for consumers that want to deal with fewer node types.
#
# source://prism//lib/prism/desugar_compiler.rb#218
class Prism::DesugarCompiler < ::Prism::MutationCompiler
# @@foo &&= bar
#
# becomes
#
# @@foo && @@foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#224
def visit_class_variable_and_write_node(node); end
# @@foo += bar
#
# becomes
#
# @@foo = @@foo + bar
#
# source://prism//lib/prism/desugar_compiler.rb#242
def visit_class_variable_operator_write_node(node); end
# @@foo ||= bar
#
# becomes
#
# defined?(@@foo) ? @@foo : @@foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#233
def visit_class_variable_or_write_node(node); end
# Foo &&= bar
#
# becomes
#
# Foo && Foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#251
def visit_constant_and_write_node(node); end
# Foo += bar
#
# becomes
#
# Foo = Foo + bar
#
# source://prism//lib/prism/desugar_compiler.rb#269
def visit_constant_operator_write_node(node); end
# Foo ||= bar
#
# becomes
#
# defined?(Foo) ? Foo : Foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#260
def visit_constant_or_write_node(node); end
# $foo &&= bar
#
# becomes
#
# $foo && $foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#278
def visit_global_variable_and_write_node(node); end
# $foo += bar
#
# becomes
#
# $foo = $foo + bar
#
# source://prism//lib/prism/desugar_compiler.rb#296
def visit_global_variable_operator_write_node(node); end
# $foo ||= bar
#
# becomes
#
# defined?($foo) ? $foo : $foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#287
def visit_global_variable_or_write_node(node); end
# becomes
#
# source://prism//lib/prism/desugar_compiler.rb#305
def visit_instance_variable_and_write_node(node); end
# becomes
#
# source://prism//lib/prism/desugar_compiler.rb#323
def visit_instance_variable_operator_write_node(node); end
# becomes
#
# source://prism//lib/prism/desugar_compiler.rb#314
def visit_instance_variable_or_write_node(node); end
# foo &&= bar
#
# becomes
#
# foo && foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#332
def visit_local_variable_and_write_node(node); end
# foo += bar
#
# becomes
#
# foo = foo + bar
#
# source://prism//lib/prism/desugar_compiler.rb#350
def visit_local_variable_operator_write_node(node); end
# foo ||= bar
#
# becomes
#
# foo || foo = bar
#
# source://prism//lib/prism/desugar_compiler.rb#341
def visit_local_variable_or_write_node(node); end
end
# source://prism//lib/prism/desugar_compiler.rb#63
class Prism::DesugarOperatorWriteNode
# @return [DesugarOperatorWriteNode] a new instance of DesugarOperatorWriteNode
#
# source://prism//lib/prism/desugar_compiler.rb#66
def initialize(node, source, read_class, write_class, *arguments); end
# Returns the value of attribute arguments.
#
# source://prism//lib/prism/desugar_compiler.rb#64
def arguments; end
# Desugar `x += y` to `x = x + y`
#
# source://prism//lib/prism/desugar_compiler.rb#75
def compile; end
# Returns the value of attribute node.
#
# source://prism//lib/prism/desugar_compiler.rb#64
def node; end
# Returns the value of attribute read_class.
#
# source://prism//lib/prism/desugar_compiler.rb#64
def read_class; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/desugar_compiler.rb#64
def source; end
# Returns the value of attribute write_class.
#
# source://prism//lib/prism/desugar_compiler.rb#64
def write_class; end
end
# source://prism//lib/prism/desugar_compiler.rb#27
class Prism::DesugarOrWriteDefinedNode
# @return [DesugarOrWriteDefinedNode] a new instance of DesugarOrWriteDefinedNode
#
# source://prism//lib/prism/desugar_compiler.rb#30
def initialize(node, source, read_class, write_class, *arguments); end
# Returns the value of attribute arguments.
#
# source://prism//lib/prism/desugar_compiler.rb#28
def arguments; end
# Desugar `x ||= y` to `defined?(x) ? x : x = y`
#
# source://prism//lib/prism/desugar_compiler.rb#39
def compile; end
# Returns the value of attribute node.
#
# source://prism//lib/prism/desugar_compiler.rb#28
def node; end
# Returns the value of attribute read_class.
#
# source://prism//lib/prism/desugar_compiler.rb#28
def read_class; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/desugar_compiler.rb#28
def source; end
# Returns the value of attribute write_class.
#
# source://prism//lib/prism/desugar_compiler.rb#28
def write_class; end
end
# source://prism//lib/prism/desugar_compiler.rb#101
class Prism::DesugarOrWriteNode
# @return [DesugarOrWriteNode] a new instance of DesugarOrWriteNode
#
# source://prism//lib/prism/desugar_compiler.rb#104
def initialize(node, source, read_class, write_class, *arguments); end
# Returns the value of attribute arguments.
#
# source://prism//lib/prism/desugar_compiler.rb#102
def arguments; end
# Desugar `x ||= y` to `x || x = y`
#
# source://prism//lib/prism/desugar_compiler.rb#113
def compile; end
# Returns the value of attribute node.
#
# source://prism//lib/prism/desugar_compiler.rb#102
def node; end
# Returns the value of attribute read_class.
#
# source://prism//lib/prism/desugar_compiler.rb#102
def read_class; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/desugar_compiler.rb#102
def source; end
# Returns the value of attribute write_class.
#
# source://prism//lib/prism/desugar_compiler.rb#102
def write_class; end
end
# The dispatcher class fires events for nodes that are found while walking an
# AST to all registered listeners. It's useful for performing different types
# of analysis on the AST while only having to walk the tree once.
#
# To use the dispatcher, you would first instantiate it and register listeners
# for the events you're interested in:
#
# class OctalListener
# def on_integer_node_enter(node)
# if node.octal? && !node.slice.start_with?("0o")
# warn("Octal integers should be written with the 0o prefix")
# end
# end
# end
#
# dispatcher = Dispatcher.new
# dispatcher.register(listener, :on_integer_node_enter)
#
# Then, you can walk any number of trees and dispatch events to the listeners:
#
# result = Prism.parse("001 + 002 + 003")
# dispatcher.dispatch(result.value)
#
# Optionally, you can also use `#dispatch_once` to dispatch enter and leave
# events for a single node without recursing further down the tree. This can
# be useful in circumstances where you want to reuse the listeners you already
# have registers but want to stop walking the tree at a certain point.
#
# integer = result.value.statements.body.first.receiver.receiver
# dispatcher.dispatch_once(integer)
#
# source://prism//lib/prism/dispatcher.rb#41
class Prism::Dispatcher < ::Prism::Visitor
# Initialize a new dispatcher.
#
# @return [Dispatcher] a new instance of Dispatcher
#
# source://prism//lib/prism/dispatcher.rb#46
def initialize; end
# Walks `root` dispatching events to all registered listeners.
#
# def dispatch: (Node) -> void
#
# source://prism//lib/prism/visitor.rb#17
def dispatch(node); end
# Dispatches a single event for `node` to all registered listeners.
#
# def dispatch_once: (Node) -> void
#
# source://prism//lib/prism/dispatcher.rb#65
def dispatch_once(node); end
# attr_reader listeners: Hash[Symbol, Array[Listener]]
#
# source://prism//lib/prism/dispatcher.rb#43
def listeners; end
# Register a listener for one or more events.
#
# def register: (Listener, *Symbol) -> void
#
# source://prism//lib/prism/dispatcher.rb#53
def register(listener, *events); end
# Dispatch enter and leave events for AliasGlobalVariableNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#71
def visit_alias_global_variable_node(node); end
# Dispatch enter and leave events for AliasMethodNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#79
def visit_alias_method_node(node); end
# Dispatch enter and leave events for AlternationPatternNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#87
def visit_alternation_pattern_node(node); end
# Dispatch enter and leave events for AndNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#95
def visit_and_node(node); end
# Dispatch enter and leave events for ArgumentsNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#103
def visit_arguments_node(node); end
# Dispatch enter and leave events for ArrayNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#111
def visit_array_node(node); end
# Dispatch enter and leave events for ArrayPatternNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#119
def visit_array_pattern_node(node); end
# Dispatch enter and leave events for AssocNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#127
def visit_assoc_node(node); end
# Dispatch enter and leave events for AssocSplatNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#135
def visit_assoc_splat_node(node); end
# Dispatch enter and leave events for BackReferenceReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#143
def visit_back_reference_read_node(node); end
# Dispatch enter and leave events for BeginNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#151
def visit_begin_node(node); end
# Dispatch enter and leave events for BlockArgumentNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#159
def visit_block_argument_node(node); end
# Dispatch enter and leave events for BlockLocalVariableNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#167
def visit_block_local_variable_node(node); end
# Dispatch enter and leave events for BlockNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#175
def visit_block_node(node); end
# Dispatch enter and leave events for BlockParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#183
def visit_block_parameter_node(node); end
# Dispatch enter and leave events for BlockParametersNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#191
def visit_block_parameters_node(node); end
# Dispatch enter and leave events for BreakNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#199
def visit_break_node(node); end
# Dispatch enter and leave events for CallAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#207
def visit_call_and_write_node(node); end
# Dispatch enter and leave events for CallNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#215
def visit_call_node(node); end
# Dispatch enter and leave events for CallOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#223
def visit_call_operator_write_node(node); end
# Dispatch enter and leave events for CallOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#231
def visit_call_or_write_node(node); end
# Dispatch enter and leave events for CallTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#239
def visit_call_target_node(node); end
# Dispatch enter and leave events for CapturePatternNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#247
def visit_capture_pattern_node(node); end
# Dispatch enter and leave events for CaseMatchNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#255
def visit_case_match_node(node); end
# Dispatch enter and leave events for CaseNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#263
def visit_case_node(node); end
# Dispatch enter and leave events for ClassNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#271
def visit_class_node(node); end
# Dispatch enter and leave events for ClassVariableAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#279
def visit_class_variable_and_write_node(node); end
# Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#287
def visit_class_variable_operator_write_node(node); end
# Dispatch enter and leave events for ClassVariableOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#295
def visit_class_variable_or_write_node(node); end
# Dispatch enter and leave events for ClassVariableReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#303
def visit_class_variable_read_node(node); end
# Dispatch enter and leave events for ClassVariableTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#311
def visit_class_variable_target_node(node); end
# Dispatch enter and leave events for ClassVariableWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#319
def visit_class_variable_write_node(node); end
# Dispatch enter and leave events for ConstantAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#327
def visit_constant_and_write_node(node); end
# Dispatch enter and leave events for ConstantOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#335
def visit_constant_operator_write_node(node); end
# Dispatch enter and leave events for ConstantOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#343
def visit_constant_or_write_node(node); end
# Dispatch enter and leave events for ConstantPathAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#351
def visit_constant_path_and_write_node(node); end
# Dispatch enter and leave events for ConstantPathNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#359
def visit_constant_path_node(node); end
# Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#367
def visit_constant_path_operator_write_node(node); end
# Dispatch enter and leave events for ConstantPathOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#375
def visit_constant_path_or_write_node(node); end
# Dispatch enter and leave events for ConstantPathTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#383
def visit_constant_path_target_node(node); end
# Dispatch enter and leave events for ConstantPathWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#391
def visit_constant_path_write_node(node); end
# Dispatch enter and leave events for ConstantReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#399
def visit_constant_read_node(node); end
# Dispatch enter and leave events for ConstantTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#407
def visit_constant_target_node(node); end
# Dispatch enter and leave events for ConstantWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#415
def visit_constant_write_node(node); end
# Dispatch enter and leave events for DefNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#423
def visit_def_node(node); end
# Dispatch enter and leave events for DefinedNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#431
def visit_defined_node(node); end
# Dispatch enter and leave events for ElseNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#439
def visit_else_node(node); end
# Dispatch enter and leave events for EmbeddedStatementsNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#447
def visit_embedded_statements_node(node); end
# Dispatch enter and leave events for EmbeddedVariableNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#455
def visit_embedded_variable_node(node); end
# Dispatch enter and leave events for EnsureNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#463
def visit_ensure_node(node); end
# Dispatch enter and leave events for FalseNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#471
def visit_false_node(node); end
# Dispatch enter and leave events for FindPatternNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#479
def visit_find_pattern_node(node); end
# Dispatch enter and leave events for FlipFlopNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#487
def visit_flip_flop_node(node); end
# Dispatch enter and leave events for FloatNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#495
def visit_float_node(node); end
# Dispatch enter and leave events for ForNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#503
def visit_for_node(node); end
# Dispatch enter and leave events for ForwardingArgumentsNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#511
def visit_forwarding_arguments_node(node); end
# Dispatch enter and leave events for ForwardingParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#519
def visit_forwarding_parameter_node(node); end
# Dispatch enter and leave events for ForwardingSuperNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#527
def visit_forwarding_super_node(node); end
# Dispatch enter and leave events for GlobalVariableAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#535
def visit_global_variable_and_write_node(node); end
# Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#543
def visit_global_variable_operator_write_node(node); end
# Dispatch enter and leave events for GlobalVariableOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#551
def visit_global_variable_or_write_node(node); end
# Dispatch enter and leave events for GlobalVariableReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#559
def visit_global_variable_read_node(node); end
# Dispatch enter and leave events for GlobalVariableTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#567
def visit_global_variable_target_node(node); end
# Dispatch enter and leave events for GlobalVariableWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#575
def visit_global_variable_write_node(node); end
# Dispatch enter and leave events for HashNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#583
def visit_hash_node(node); end
# Dispatch enter and leave events for HashPatternNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#591
def visit_hash_pattern_node(node); end
# Dispatch enter and leave events for IfNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#599
def visit_if_node(node); end
# Dispatch enter and leave events for ImaginaryNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#607
def visit_imaginary_node(node); end
# Dispatch enter and leave events for ImplicitNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#615
def visit_implicit_node(node); end
# Dispatch enter and leave events for ImplicitRestNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#623
def visit_implicit_rest_node(node); end
# Dispatch enter and leave events for InNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#631
def visit_in_node(node); end
# Dispatch enter and leave events for IndexAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#639
def visit_index_and_write_node(node); end
# Dispatch enter and leave events for IndexOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#647
def visit_index_operator_write_node(node); end
# Dispatch enter and leave events for IndexOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#655
def visit_index_or_write_node(node); end
# Dispatch enter and leave events for IndexTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#663
def visit_index_target_node(node); end
# Dispatch enter and leave events for InstanceVariableAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#671
def visit_instance_variable_and_write_node(node); end
# Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#679
def visit_instance_variable_operator_write_node(node); end
# Dispatch enter and leave events for InstanceVariableOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#687
def visit_instance_variable_or_write_node(node); end
# Dispatch enter and leave events for InstanceVariableReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#695
def visit_instance_variable_read_node(node); end
# Dispatch enter and leave events for InstanceVariableTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#703
def visit_instance_variable_target_node(node); end
# Dispatch enter and leave events for InstanceVariableWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#711
def visit_instance_variable_write_node(node); end
# Dispatch enter and leave events for IntegerNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#719
def visit_integer_node(node); end
# Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#727
def visit_interpolated_match_last_line_node(node); end
# Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#735
def visit_interpolated_regular_expression_node(node); end
# Dispatch enter and leave events for InterpolatedStringNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#743
def visit_interpolated_string_node(node); end
# Dispatch enter and leave events for InterpolatedSymbolNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#751
def visit_interpolated_symbol_node(node); end
# Dispatch enter and leave events for InterpolatedXStringNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#759
def visit_interpolated_x_string_node(node); end
# Dispatch enter and leave events for ItLocalVariableReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#767
def visit_it_local_variable_read_node(node); end
# Dispatch enter and leave events for ItParametersNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#775
def visit_it_parameters_node(node); end
# Dispatch enter and leave events for KeywordHashNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#783
def visit_keyword_hash_node(node); end
# Dispatch enter and leave events for KeywordRestParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#791
def visit_keyword_rest_parameter_node(node); end
# Dispatch enter and leave events for LambdaNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#799
def visit_lambda_node(node); end
# Dispatch enter and leave events for LocalVariableAndWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#807
def visit_local_variable_and_write_node(node); end
# Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#815
def visit_local_variable_operator_write_node(node); end
# Dispatch enter and leave events for LocalVariableOrWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#823
def visit_local_variable_or_write_node(node); end
# Dispatch enter and leave events for LocalVariableReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#831
def visit_local_variable_read_node(node); end
# Dispatch enter and leave events for LocalVariableTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#839
def visit_local_variable_target_node(node); end
# Dispatch enter and leave events for LocalVariableWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#847
def visit_local_variable_write_node(node); end
# Dispatch enter and leave events for MatchLastLineNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#855
def visit_match_last_line_node(node); end
# Dispatch enter and leave events for MatchPredicateNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#863
def visit_match_predicate_node(node); end
# Dispatch enter and leave events for MatchRequiredNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#871
def visit_match_required_node(node); end
# Dispatch enter and leave events for MatchWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#879
def visit_match_write_node(node); end
# Dispatch enter and leave events for MissingNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#887
def visit_missing_node(node); end
# Dispatch enter and leave events for ModuleNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#895
def visit_module_node(node); end
# Dispatch enter and leave events for MultiTargetNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#903
def visit_multi_target_node(node); end
# Dispatch enter and leave events for MultiWriteNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#911
def visit_multi_write_node(node); end
# Dispatch enter and leave events for NextNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#919
def visit_next_node(node); end
# Dispatch enter and leave events for NilNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#927
def visit_nil_node(node); end
# Dispatch enter and leave events for NoKeywordsParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#935
def visit_no_keywords_parameter_node(node); end
# Dispatch enter and leave events for NumberedParametersNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#943
def visit_numbered_parameters_node(node); end
# Dispatch enter and leave events for NumberedReferenceReadNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#951
def visit_numbered_reference_read_node(node); end
# Dispatch enter and leave events for OptionalKeywordParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#959
def visit_optional_keyword_parameter_node(node); end
# Dispatch enter and leave events for OptionalParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#967
def visit_optional_parameter_node(node); end
# Dispatch enter and leave events for OrNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#975
def visit_or_node(node); end
# Dispatch enter and leave events for ParametersNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#983
def visit_parameters_node(node); end
# Dispatch enter and leave events for ParenthesesNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#991
def visit_parentheses_node(node); end
# Dispatch enter and leave events for PinnedExpressionNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#999
def visit_pinned_expression_node(node); end
# Dispatch enter and leave events for PinnedVariableNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1007
def visit_pinned_variable_node(node); end
# Dispatch enter and leave events for PostExecutionNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1015
def visit_post_execution_node(node); end
# Dispatch enter and leave events for PreExecutionNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1023
def visit_pre_execution_node(node); end
# Dispatch enter and leave events for ProgramNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1031
def visit_program_node(node); end
# Dispatch enter and leave events for RangeNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1039
def visit_range_node(node); end
# Dispatch enter and leave events for RationalNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1047
def visit_rational_node(node); end
# Dispatch enter and leave events for RedoNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1055
def visit_redo_node(node); end
# Dispatch enter and leave events for RegularExpressionNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1063
def visit_regular_expression_node(node); end
# Dispatch enter and leave events for RequiredKeywordParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1071
def visit_required_keyword_parameter_node(node); end
# Dispatch enter and leave events for RequiredParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1079
def visit_required_parameter_node(node); end
# Dispatch enter and leave events for RescueModifierNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1087
def visit_rescue_modifier_node(node); end
# Dispatch enter and leave events for RescueNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1095
def visit_rescue_node(node); end
# Dispatch enter and leave events for RestParameterNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1103
def visit_rest_parameter_node(node); end
# Dispatch enter and leave events for RetryNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1111
def visit_retry_node(node); end
# Dispatch enter and leave events for ReturnNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1119
def visit_return_node(node); end
# Dispatch enter and leave events for SelfNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1127
def visit_self_node(node); end
# Dispatch enter and leave events for ShareableConstantNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1135
def visit_shareable_constant_node(node); end
# Dispatch enter and leave events for SingletonClassNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1143
def visit_singleton_class_node(node); end
# Dispatch enter and leave events for SourceEncodingNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1151
def visit_source_encoding_node(node); end
# Dispatch enter and leave events for SourceFileNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1159
def visit_source_file_node(node); end
# Dispatch enter and leave events for SourceLineNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1167
def visit_source_line_node(node); end
# Dispatch enter and leave events for SplatNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1175
def visit_splat_node(node); end
# Dispatch enter and leave events for StatementsNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1183
def visit_statements_node(node); end
# Dispatch enter and leave events for StringNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1191
def visit_string_node(node); end
# Dispatch enter and leave events for SuperNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1199
def visit_super_node(node); end
# Dispatch enter and leave events for SymbolNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1207
def visit_symbol_node(node); end
# Dispatch enter and leave events for TrueNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1215
def visit_true_node(node); end
# Dispatch enter and leave events for UndefNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1223
def visit_undef_node(node); end
# Dispatch enter and leave events for UnlessNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1231
def visit_unless_node(node); end
# Dispatch enter and leave events for UntilNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1239
def visit_until_node(node); end
# Dispatch enter and leave events for WhenNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1247
def visit_when_node(node); end
# Dispatch enter and leave events for WhileNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1255
def visit_while_node(node); end
# Dispatch enter and leave events for XStringNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1263
def visit_x_string_node(node); end
# Dispatch enter and leave events for YieldNode nodes and continue
# walking the tree.
#
# source://prism//lib/prism/dispatcher.rb#1271
def visit_yield_node(node); end
end
# source://prism//lib/prism/dispatcher.rb#1277
class Prism::Dispatcher::DispatchOnce < ::Prism::Visitor
# @return [DispatchOnce] a new instance of DispatchOnce
#
# source://prism//lib/prism/dispatcher.rb#1280
def initialize(listeners); end
# Returns the value of attribute listeners.
#
# source://prism//lib/prism/dispatcher.rb#1278
def listeners; end
# Dispatch enter and leave events for AliasGlobalVariableNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1285
def visit_alias_global_variable_node(node); end
# Dispatch enter and leave events for AliasMethodNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1291
def visit_alias_method_node(node); end
# Dispatch enter and leave events for AlternationPatternNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1297
def visit_alternation_pattern_node(node); end
# Dispatch enter and leave events for AndNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1303
def visit_and_node(node); end
# Dispatch enter and leave events for ArgumentsNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1309
def visit_arguments_node(node); end
# Dispatch enter and leave events for ArrayNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1315
def visit_array_node(node); end
# Dispatch enter and leave events for ArrayPatternNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1321
def visit_array_pattern_node(node); end
# Dispatch enter and leave events for AssocNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1327
def visit_assoc_node(node); end
# Dispatch enter and leave events for AssocSplatNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1333
def visit_assoc_splat_node(node); end
# Dispatch enter and leave events for BackReferenceReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1339
def visit_back_reference_read_node(node); end
# Dispatch enter and leave events for BeginNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1345
def visit_begin_node(node); end
# Dispatch enter and leave events for BlockArgumentNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1351
def visit_block_argument_node(node); end
# Dispatch enter and leave events for BlockLocalVariableNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1357
def visit_block_local_variable_node(node); end
# Dispatch enter and leave events for BlockNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1363
def visit_block_node(node); end
# Dispatch enter and leave events for BlockParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1369
def visit_block_parameter_node(node); end
# Dispatch enter and leave events for BlockParametersNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1375
def visit_block_parameters_node(node); end
# Dispatch enter and leave events for BreakNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1381
def visit_break_node(node); end
# Dispatch enter and leave events for CallAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1387
def visit_call_and_write_node(node); end
# Dispatch enter and leave events for CallNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1393
def visit_call_node(node); end
# Dispatch enter and leave events for CallOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1399
def visit_call_operator_write_node(node); end
# Dispatch enter and leave events for CallOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1405
def visit_call_or_write_node(node); end
# Dispatch enter and leave events for CallTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1411
def visit_call_target_node(node); end
# Dispatch enter and leave events for CapturePatternNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1417
def visit_capture_pattern_node(node); end
# Dispatch enter and leave events for CaseMatchNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1423
def visit_case_match_node(node); end
# Dispatch enter and leave events for CaseNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1429
def visit_case_node(node); end
# Dispatch enter and leave events for ClassNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1435
def visit_class_node(node); end
# Dispatch enter and leave events for ClassVariableAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1441
def visit_class_variable_and_write_node(node); end
# Dispatch enter and leave events for ClassVariableOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1447
def visit_class_variable_operator_write_node(node); end
# Dispatch enter and leave events for ClassVariableOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1453
def visit_class_variable_or_write_node(node); end
# Dispatch enter and leave events for ClassVariableReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1459
def visit_class_variable_read_node(node); end
# Dispatch enter and leave events for ClassVariableTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1465
def visit_class_variable_target_node(node); end
# Dispatch enter and leave events for ClassVariableWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1471
def visit_class_variable_write_node(node); end
# Dispatch enter and leave events for ConstantAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1477
def visit_constant_and_write_node(node); end
# Dispatch enter and leave events for ConstantOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1483
def visit_constant_operator_write_node(node); end
# Dispatch enter and leave events for ConstantOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1489
def visit_constant_or_write_node(node); end
# Dispatch enter and leave events for ConstantPathAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1495
def visit_constant_path_and_write_node(node); end
# Dispatch enter and leave events for ConstantPathNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1501
def visit_constant_path_node(node); end
# Dispatch enter and leave events for ConstantPathOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1507
def visit_constant_path_operator_write_node(node); end
# Dispatch enter and leave events for ConstantPathOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1513
def visit_constant_path_or_write_node(node); end
# Dispatch enter and leave events for ConstantPathTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1519
def visit_constant_path_target_node(node); end
# Dispatch enter and leave events for ConstantPathWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1525
def visit_constant_path_write_node(node); end
# Dispatch enter and leave events for ConstantReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1531
def visit_constant_read_node(node); end
# Dispatch enter and leave events for ConstantTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1537
def visit_constant_target_node(node); end
# Dispatch enter and leave events for ConstantWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1543
def visit_constant_write_node(node); end
# Dispatch enter and leave events for DefNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1549
def visit_def_node(node); end
# Dispatch enter and leave events for DefinedNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1555
def visit_defined_node(node); end
# Dispatch enter and leave events for ElseNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1561
def visit_else_node(node); end
# Dispatch enter and leave events for EmbeddedStatementsNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1567
def visit_embedded_statements_node(node); end
# Dispatch enter and leave events for EmbeddedVariableNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1573
def visit_embedded_variable_node(node); end
# Dispatch enter and leave events for EnsureNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1579
def visit_ensure_node(node); end
# Dispatch enter and leave events for FalseNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1585
def visit_false_node(node); end
# Dispatch enter and leave events for FindPatternNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1591
def visit_find_pattern_node(node); end
# Dispatch enter and leave events for FlipFlopNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1597
def visit_flip_flop_node(node); end
# Dispatch enter and leave events for FloatNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1603
def visit_float_node(node); end
# Dispatch enter and leave events for ForNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1609
def visit_for_node(node); end
# Dispatch enter and leave events for ForwardingArgumentsNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1615
def visit_forwarding_arguments_node(node); end
# Dispatch enter and leave events for ForwardingParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1621
def visit_forwarding_parameter_node(node); end
# Dispatch enter and leave events for ForwardingSuperNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1627
def visit_forwarding_super_node(node); end
# Dispatch enter and leave events for GlobalVariableAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1633
def visit_global_variable_and_write_node(node); end
# Dispatch enter and leave events for GlobalVariableOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1639
def visit_global_variable_operator_write_node(node); end
# Dispatch enter and leave events for GlobalVariableOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1645
def visit_global_variable_or_write_node(node); end
# Dispatch enter and leave events for GlobalVariableReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1651
def visit_global_variable_read_node(node); end
# Dispatch enter and leave events for GlobalVariableTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1657
def visit_global_variable_target_node(node); end
# Dispatch enter and leave events for GlobalVariableWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1663
def visit_global_variable_write_node(node); end
# Dispatch enter and leave events for HashNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1669
def visit_hash_node(node); end
# Dispatch enter and leave events for HashPatternNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1675
def visit_hash_pattern_node(node); end
# Dispatch enter and leave events for IfNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1681
def visit_if_node(node); end
# Dispatch enter and leave events for ImaginaryNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1687
def visit_imaginary_node(node); end
# Dispatch enter and leave events for ImplicitNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1693
def visit_implicit_node(node); end
# Dispatch enter and leave events for ImplicitRestNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1699
def visit_implicit_rest_node(node); end
# Dispatch enter and leave events for InNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1705
def visit_in_node(node); end
# Dispatch enter and leave events for IndexAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1711
def visit_index_and_write_node(node); end
# Dispatch enter and leave events for IndexOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1717
def visit_index_operator_write_node(node); end
# Dispatch enter and leave events for IndexOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1723
def visit_index_or_write_node(node); end
# Dispatch enter and leave events for IndexTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1729
def visit_index_target_node(node); end
# Dispatch enter and leave events for InstanceVariableAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1735
def visit_instance_variable_and_write_node(node); end
# Dispatch enter and leave events for InstanceVariableOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1741
def visit_instance_variable_operator_write_node(node); end
# Dispatch enter and leave events for InstanceVariableOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1747
def visit_instance_variable_or_write_node(node); end
# Dispatch enter and leave events for InstanceVariableReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1753
def visit_instance_variable_read_node(node); end
# Dispatch enter and leave events for InstanceVariableTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1759
def visit_instance_variable_target_node(node); end
# Dispatch enter and leave events for InstanceVariableWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1765
def visit_instance_variable_write_node(node); end
# Dispatch enter and leave events for IntegerNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1771
def visit_integer_node(node); end
# Dispatch enter and leave events for InterpolatedMatchLastLineNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1777
def visit_interpolated_match_last_line_node(node); end
# Dispatch enter and leave events for InterpolatedRegularExpressionNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1783
def visit_interpolated_regular_expression_node(node); end
# Dispatch enter and leave events for InterpolatedStringNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1789
def visit_interpolated_string_node(node); end
# Dispatch enter and leave events for InterpolatedSymbolNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1795
def visit_interpolated_symbol_node(node); end
# Dispatch enter and leave events for InterpolatedXStringNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1801
def visit_interpolated_x_string_node(node); end
# Dispatch enter and leave events for ItLocalVariableReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1807
def visit_it_local_variable_read_node(node); end
# Dispatch enter and leave events for ItParametersNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1813
def visit_it_parameters_node(node); end
# Dispatch enter and leave events for KeywordHashNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1819
def visit_keyword_hash_node(node); end
# Dispatch enter and leave events for KeywordRestParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1825
def visit_keyword_rest_parameter_node(node); end
# Dispatch enter and leave events for LambdaNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1831
def visit_lambda_node(node); end
# Dispatch enter and leave events for LocalVariableAndWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1837
def visit_local_variable_and_write_node(node); end
# Dispatch enter and leave events for LocalVariableOperatorWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1843
def visit_local_variable_operator_write_node(node); end
# Dispatch enter and leave events for LocalVariableOrWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1849
def visit_local_variable_or_write_node(node); end
# Dispatch enter and leave events for LocalVariableReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1855
def visit_local_variable_read_node(node); end
# Dispatch enter and leave events for LocalVariableTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1861
def visit_local_variable_target_node(node); end
# Dispatch enter and leave events for LocalVariableWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1867
def visit_local_variable_write_node(node); end
# Dispatch enter and leave events for MatchLastLineNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1873
def visit_match_last_line_node(node); end
# Dispatch enter and leave events for MatchPredicateNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1879
def visit_match_predicate_node(node); end
# Dispatch enter and leave events for MatchRequiredNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1885
def visit_match_required_node(node); end
# Dispatch enter and leave events for MatchWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1891
def visit_match_write_node(node); end
# Dispatch enter and leave events for MissingNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1897
def visit_missing_node(node); end
# Dispatch enter and leave events for ModuleNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1903
def visit_module_node(node); end
# Dispatch enter and leave events for MultiTargetNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1909
def visit_multi_target_node(node); end
# Dispatch enter and leave events for MultiWriteNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1915
def visit_multi_write_node(node); end
# Dispatch enter and leave events for NextNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1921
def visit_next_node(node); end
# Dispatch enter and leave events for NilNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1927
def visit_nil_node(node); end
# Dispatch enter and leave events for NoKeywordsParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1933
def visit_no_keywords_parameter_node(node); end
# Dispatch enter and leave events for NumberedParametersNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1939
def visit_numbered_parameters_node(node); end
# Dispatch enter and leave events for NumberedReferenceReadNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1945
def visit_numbered_reference_read_node(node); end
# Dispatch enter and leave events for OptionalKeywordParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1951
def visit_optional_keyword_parameter_node(node); end
# Dispatch enter and leave events for OptionalParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1957
def visit_optional_parameter_node(node); end
# Dispatch enter and leave events for OrNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1963
def visit_or_node(node); end
# Dispatch enter and leave events for ParametersNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1969
def visit_parameters_node(node); end
# Dispatch enter and leave events for ParenthesesNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1975
def visit_parentheses_node(node); end
# Dispatch enter and leave events for PinnedExpressionNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1981
def visit_pinned_expression_node(node); end
# Dispatch enter and leave events for PinnedVariableNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1987
def visit_pinned_variable_node(node); end
# Dispatch enter and leave events for PostExecutionNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1993
def visit_post_execution_node(node); end
# Dispatch enter and leave events for PreExecutionNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#1999
def visit_pre_execution_node(node); end
# Dispatch enter and leave events for ProgramNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2005
def visit_program_node(node); end
# Dispatch enter and leave events for RangeNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2011
def visit_range_node(node); end
# Dispatch enter and leave events for RationalNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2017
def visit_rational_node(node); end
# Dispatch enter and leave events for RedoNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2023
def visit_redo_node(node); end
# Dispatch enter and leave events for RegularExpressionNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2029
def visit_regular_expression_node(node); end
# Dispatch enter and leave events for RequiredKeywordParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2035
def visit_required_keyword_parameter_node(node); end
# Dispatch enter and leave events for RequiredParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2041
def visit_required_parameter_node(node); end
# Dispatch enter and leave events for RescueModifierNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2047
def visit_rescue_modifier_node(node); end
# Dispatch enter and leave events for RescueNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2053
def visit_rescue_node(node); end
# Dispatch enter and leave events for RestParameterNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2059
def visit_rest_parameter_node(node); end
# Dispatch enter and leave events for RetryNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2065
def visit_retry_node(node); end
# Dispatch enter and leave events for ReturnNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2071
def visit_return_node(node); end
# Dispatch enter and leave events for SelfNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2077
def visit_self_node(node); end
# Dispatch enter and leave events for ShareableConstantNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2083
def visit_shareable_constant_node(node); end
# Dispatch enter and leave events for SingletonClassNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2089
def visit_singleton_class_node(node); end
# Dispatch enter and leave events for SourceEncodingNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2095
def visit_source_encoding_node(node); end
# Dispatch enter and leave events for SourceFileNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2101
def visit_source_file_node(node); end
# Dispatch enter and leave events for SourceLineNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2107
def visit_source_line_node(node); end
# Dispatch enter and leave events for SplatNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2113
def visit_splat_node(node); end
# Dispatch enter and leave events for StatementsNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2119
def visit_statements_node(node); end
# Dispatch enter and leave events for StringNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2125
def visit_string_node(node); end
# Dispatch enter and leave events for SuperNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2131
def visit_super_node(node); end
# Dispatch enter and leave events for SymbolNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2137
def visit_symbol_node(node); end
# Dispatch enter and leave events for TrueNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2143
def visit_true_node(node); end
# Dispatch enter and leave events for UndefNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2149
def visit_undef_node(node); end
# Dispatch enter and leave events for UnlessNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2155
def visit_unless_node(node); end
# Dispatch enter and leave events for UntilNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2161
def visit_until_node(node); end
# Dispatch enter and leave events for WhenNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2167
def visit_when_node(node); end
# Dispatch enter and leave events for WhileNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2173
def visit_while_node(node); end
# Dispatch enter and leave events for XStringNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2179
def visit_x_string_node(node); end
# Dispatch enter and leave events for YieldNode nodes.
#
# source://prism//lib/prism/dispatcher.rb#2185
def visit_yield_node(node); end
end
# This visitor provides the ability to call Node#to_dot, which converts a
# subtree into a graphviz dot graph.
#
# source://prism//lib/prism/dot_visitor.rb#14
class Prism::DotVisitor < ::Prism::Visitor
# Initialize a new dot visitor.
#
# @return [DotVisitor] a new instance of DotVisitor
#
# source://prism//lib/prism/dot_visitor.rb#106
def initialize; end
# The digraph that is being built.
#
# source://prism//lib/prism/dot_visitor.rb#103
def digraph; end
# Convert this visitor into a graphviz dot graph string.
#
# source://prism//lib/prism/dot_visitor.rb#111
def to_dot; end
# Visit a AliasGlobalVariableNode node.
#
# source://prism//lib/prism/dot_visitor.rb#116
def visit_alias_global_variable_node(node); end
# Visit a AliasMethodNode node.
#
# source://prism//lib/prism/dot_visitor.rb#141
def visit_alias_method_node(node); end
# Visit a AlternationPatternNode node.
#
# source://prism//lib/prism/dot_visitor.rb#166
def visit_alternation_pattern_node(node); end
# Visit a AndNode node.
#
# source://prism//lib/prism/dot_visitor.rb#191
def visit_and_node(node); end
# Visit a ArgumentsNode node.
#
# source://prism//lib/prism/dot_visitor.rb#216
def visit_arguments_node(node); end
# Visit a ArrayNode node.
#
# source://prism//lib/prism/dot_visitor.rb#246
def visit_array_node(node); end
# Visit a ArrayPatternNode node.
#
# source://prism//lib/prism/dot_visitor.rb#286
def visit_array_pattern_node(node); end
# Visit a AssocNode node.
#
# source://prism//lib/prism/dot_visitor.rb#348
def visit_assoc_node(node); end
# Visit a AssocSplatNode node.
#
# source://prism//lib/prism/dot_visitor.rb#375
def visit_assoc_splat_node(node); end
# Visit a BackReferenceReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#398
def visit_back_reference_read_node(node); end
# Visit a BeginNode node.
#
# source://prism//lib/prism/dot_visitor.rb#415
def visit_begin_node(node); end
# Visit a BlockArgumentNode node.
#
# source://prism//lib/prism/dot_visitor.rb#463
def visit_block_argument_node(node); end
# Visit a BlockLocalVariableNode node.
#
# source://prism//lib/prism/dot_visitor.rb#486
def visit_block_local_variable_node(node); end
# Visit a BlockNode node.
#
# source://prism//lib/prism/dot_visitor.rb#506
def visit_block_node(node); end
# Visit a BlockParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#541
def visit_block_parameter_node(node); end
# Visit a BlockParametersNode node.
#
# source://prism//lib/prism/dot_visitor.rb#569
def visit_block_parameters_node(node); end
# Visit a BreakNode node.
#
# source://prism//lib/prism/dot_visitor.rb#612
def visit_break_node(node); end
# Visit a CallAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#635
def visit_call_and_write_node(node); end
# Visit a CallNode node.
#
# source://prism//lib/prism/dot_visitor.rb#681
def visit_call_node(node); end
# Visit a CallOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#739
def visit_call_operator_write_node(node); end
# Visit a CallOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#788
def visit_call_or_write_node(node); end
# Visit a CallTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#834
def visit_call_target_node(node); end
# Visit a CapturePatternNode node.
#
# source://prism//lib/prism/dot_visitor.rb#864
def visit_capture_pattern_node(node); end
# Visit a CaseMatchNode node.
#
# source://prism//lib/prism/dot_visitor.rb#889
def visit_case_match_node(node); end
# Visit a CaseNode node.
#
# source://prism//lib/prism/dot_visitor.rb#934
def visit_case_node(node); end
# Visit a ClassNode node.
#
# source://prism//lib/prism/dot_visitor.rb#979
def visit_class_node(node); end
# Visit a ClassVariableAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1026
def visit_class_variable_and_write_node(node); end
# Visit a ClassVariableOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1053
def visit_class_variable_operator_write_node(node); end
# Visit a ClassVariableOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1083
def visit_class_variable_or_write_node(node); end
# Visit a ClassVariableReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1110
def visit_class_variable_read_node(node); end
# Visit a ClassVariableTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1127
def visit_class_variable_target_node(node); end
# Visit a ClassVariableWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1144
def visit_class_variable_write_node(node); end
# Visit a ConstantAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1171
def visit_constant_and_write_node(node); end
# Visit a ConstantOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1198
def visit_constant_operator_write_node(node); end
# Visit a ConstantOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1228
def visit_constant_or_write_node(node); end
# Visit a ConstantPathAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1255
def visit_constant_path_and_write_node(node); end
# Visit a ConstantPathNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1280
def visit_constant_path_node(node); end
# Visit a ConstantPathOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1309
def visit_constant_path_operator_write_node(node); end
# Visit a ConstantPathOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1337
def visit_constant_path_or_write_node(node); end
# Visit a ConstantPathTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1362
def visit_constant_path_target_node(node); end
# Visit a ConstantPathWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1391
def visit_constant_path_write_node(node); end
# Visit a ConstantReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1416
def visit_constant_read_node(node); end
# Visit a ConstantTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1433
def visit_constant_target_node(node); end
# Visit a ConstantWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1450
def visit_constant_write_node(node); end
# Visit a DefNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1477
def visit_def_node(node); end
# Visit a DefinedNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1546
def visit_defined_node(node); end
# Visit a ElseNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1577
def visit_else_node(node); end
# Visit a EmbeddedStatementsNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1605
def visit_embedded_statements_node(node); end
# Visit a EmbeddedVariableNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1631
def visit_embedded_variable_node(node); end
# Visit a EnsureNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1652
def visit_ensure_node(node); end
# Visit a FalseNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1678
def visit_false_node(node); end
# Visit a FindPatternNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1692
def visit_find_pattern_node(node); end
# Visit a FlipFlopNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1743
def visit_flip_flop_node(node); end
# Visit a FloatNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1775
def visit_float_node(node); end
# Visit a ForNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1792
def visit_for_node(node); end
# Visit a ForwardingArgumentsNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1834
def visit_forwarding_arguments_node(node); end
# Visit a ForwardingParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1848
def visit_forwarding_parameter_node(node); end
# Visit a ForwardingSuperNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1862
def visit_forwarding_super_node(node); end
# Visit a GlobalVariableAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1882
def visit_global_variable_and_write_node(node); end
# Visit a GlobalVariableOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1909
def visit_global_variable_operator_write_node(node); end
# Visit a GlobalVariableOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1939
def visit_global_variable_or_write_node(node); end
# Visit a GlobalVariableReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1966
def visit_global_variable_read_node(node); end
# Visit a GlobalVariableTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#1983
def visit_global_variable_target_node(node); end
# Visit a GlobalVariableWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2000
def visit_global_variable_write_node(node); end
# Visit a HashNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2027
def visit_hash_node(node); end
# Visit a HashPatternNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2060
def visit_hash_pattern_node(node); end
# Visit a IfNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2109
def visit_if_node(node); end
# Visit a ImaginaryNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2154
def visit_imaginary_node(node); end
# Visit a ImplicitNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2172
def visit_implicit_node(node); end
# Visit a ImplicitRestNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2190
def visit_implicit_rest_node(node); end
# Visit a InNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2204
def visit_in_node(node); end
# Visit a IndexAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2236
def visit_index_and_write_node(node); end
# Visit a IndexOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2289
def visit_index_operator_write_node(node); end
# Visit a IndexOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2345
def visit_index_or_write_node(node); end
# Visit a IndexTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2398
def visit_index_target_node(node); end
# Visit a InstanceVariableAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2437
def visit_instance_variable_and_write_node(node); end
# Visit a InstanceVariableOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2464
def visit_instance_variable_operator_write_node(node); end
# Visit a InstanceVariableOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2494
def visit_instance_variable_or_write_node(node); end
# Visit a InstanceVariableReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2521
def visit_instance_variable_read_node(node); end
# Visit a InstanceVariableTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2538
def visit_instance_variable_target_node(node); end
# Visit a InstanceVariableWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2555
def visit_instance_variable_write_node(node); end
# Visit a IntegerNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2582
def visit_integer_node(node); end
# Visit a InterpolatedMatchLastLineNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2602
def visit_interpolated_match_last_line_node(node); end
# Visit a InterpolatedRegularExpressionNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2638
def visit_interpolated_regular_expression_node(node); end
# Visit a InterpolatedStringNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2674
def visit_interpolated_string_node(node); end
# Visit a InterpolatedSymbolNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2714
def visit_interpolated_symbol_node(node); end
# Visit a InterpolatedXStringNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2751
def visit_interpolated_x_string_node(node); end
# Visit a ItLocalVariableReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2784
def visit_it_local_variable_read_node(node); end
# Visit a ItParametersNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2798
def visit_it_parameters_node(node); end
# Visit a KeywordHashNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2812
def visit_keyword_hash_node(node); end
# Visit a KeywordRestParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2842
def visit_keyword_rest_parameter_node(node); end
# Visit a LambdaNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2870
def visit_lambda_node(node); end
# Visit a LocalVariableAndWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2908
def visit_local_variable_and_write_node(node); end
# Visit a LocalVariableOperatorWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2938
def visit_local_variable_operator_write_node(node); end
# Visit a LocalVariableOrWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#2971
def visit_local_variable_or_write_node(node); end
# Visit a LocalVariableReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3001
def visit_local_variable_read_node(node); end
# Visit a LocalVariableTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3021
def visit_local_variable_target_node(node); end
# Visit a LocalVariableWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3041
def visit_local_variable_write_node(node); end
# Visit a MatchLastLineNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3071
def visit_match_last_line_node(node); end
# Visit a MatchPredicateNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3100
def visit_match_predicate_node(node); end
# Visit a MatchRequiredNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3125
def visit_match_required_node(node); end
# Visit a MatchWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3150
def visit_match_write_node(node); end
# Visit a MissingNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3181
def visit_missing_node(node); end
# Visit a ModuleNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3195
def visit_module_node(node); end
# Visit a MultiTargetNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3231
def visit_multi_target_node(node); end
# Visit a MultiWriteNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3287
def visit_multi_write_node(node); end
# Visit a NextNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3350
def visit_next_node(node); end
# Visit a NilNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3373
def visit_nil_node(node); end
# Visit a NoKeywordsParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3387
def visit_no_keywords_parameter_node(node); end
# Visit a NumberedParametersNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3407
def visit_numbered_parameters_node(node); end
# Visit a NumberedReferenceReadNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3424
def visit_numbered_reference_read_node(node); end
# Visit a OptionalKeywordParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3441
def visit_optional_keyword_parameter_node(node); end
# Visit a OptionalParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3468
def visit_optional_parameter_node(node); end
# Visit a OrNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3498
def visit_or_node(node); end
# Visit a ParametersNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3523
def visit_parameters_node(node); end
# Visit a ParenthesesNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3607
def visit_parentheses_node(node); end
# Visit a PinnedExpressionNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3633
def visit_pinned_expression_node(node); end
# Visit a PinnedVariableNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3660
def visit_pinned_variable_node(node); end
# Visit a PostExecutionNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3681
def visit_post_execution_node(node); end
# Visit a PreExecutionNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3710
def visit_pre_execution_node(node); end
# Visit a ProgramNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3739
def visit_program_node(node); end
# Visit a RangeNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3760
def visit_range_node(node); end
# Visit a RationalNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3792
def visit_rational_node(node); end
# Visit a RedoNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3815
def visit_redo_node(node); end
# Visit a RegularExpressionNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3829
def visit_regular_expression_node(node); end
# Visit a RequiredKeywordParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3858
def visit_required_keyword_parameter_node(node); end
# Visit a RequiredParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3881
def visit_required_parameter_node(node); end
# Visit a RescueModifierNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3901
def visit_rescue_modifier_node(node); end
# Visit a RescueNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3926
def visit_rescue_node(node); end
# Visit a RestParameterNode node.
#
# source://prism//lib/prism/dot_visitor.rb#3979
def visit_rest_parameter_node(node); end
# Visit a RetryNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4007
def visit_retry_node(node); end
# Visit a ReturnNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4021
def visit_return_node(node); end
# Visit a SelfNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4047
def visit_self_node(node); end
# Visit a ShareableConstantNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4061
def visit_shareable_constant_node(node); end
# Visit a SingletonClassNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4082
def visit_singleton_class_node(node); end
# Visit a SourceEncodingNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4118
def visit_source_encoding_node(node); end
# Visit a SourceFileNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4132
def visit_source_file_node(node); end
# Visit a SourceLineNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4152
def visit_source_line_node(node); end
# Visit a SplatNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4166
def visit_splat_node(node); end
# Visit a StatementsNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4189
def visit_statements_node(node); end
# Visit a StringNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4216
def visit_string_node(node); end
# Visit a SuperNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4249
def visit_super_node(node); end
# Visit a SymbolNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4288
def visit_symbol_node(node); end
# Visit a TrueNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4323
def visit_true_node(node); end
# Visit a UndefNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4337
def visit_undef_node(node); end
# Visit a UnlessNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4367
def visit_unless_node(node); end
# Visit a UntilNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4410
def visit_until_node(node); end
# Visit a WhenNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4445
def visit_when_node(node); end
# Visit a WhileNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4486
def visit_while_node(node); end
# Visit a XStringNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4521
def visit_x_string_node(node); end
# Visit a YieldNode node.
#
# source://prism//lib/prism/dot_visitor.rb#4550
def visit_yield_node(node); end
private
# Inspect a node that has arguments_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4596
def arguments_node_flags_inspect(node); end
# Inspect a node that has array_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4605
def array_node_flags_inspect(node); end
# Inspect a node that has call_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4613
def call_node_flags_inspect(node); end
# Inspect a node that has encoding_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4624
def encoding_flags_inspect(node); end
# Inspect a node that has integer_base_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4633
def integer_base_flags_inspect(node); end
# Inspect a node that has interpolated_string_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4644
def interpolated_string_node_flags_inspect(node); end
# Inspect a node that has keyword_hash_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4653
def keyword_hash_node_flags_inspect(node); end
# Inspect a location to display the start and end line and column numbers.
#
# source://prism//lib/prism/dot_visitor.rb#4590
def location_inspect(location); end
# Inspect a node that has loop_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4661
def loop_flags_inspect(node); end
# Generate a unique node ID for a node throughout the digraph.
#
# source://prism//lib/prism/dot_visitor.rb#4585
def node_id(node); end
# Inspect a node that has parameter_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4669
def parameter_flags_inspect(node); end
# Inspect a node that has range_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4677
def range_flags_inspect(node); end
# Inspect a node that has regular_expression_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4685
def regular_expression_flags_inspect(node); end
# Inspect a node that has return_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4703
def return_node_flags_inspect(node); end
# Inspect a node that has shareable_constant_node_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4711
def shareable_constant_node_flags_inspect(node); end
# Inspect a node that has string_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4721
def string_flags_inspect(node); end
# Inspect a node that has symbol_flags flags to display the flags as a
# comma-separated list.
#
# source://prism//lib/prism/dot_visitor.rb#4732
def symbol_flags_inspect(node); end
end
# source://prism//lib/prism/dot_visitor.rb#59
class Prism::DotVisitor::Digraph
# @return [Digraph] a new instance of Digraph
#
# source://prism//lib/prism/dot_visitor.rb#62
def initialize; end
# source://prism//lib/prism/dot_visitor.rb#76
def edge(value); end
# Returns the value of attribute edges.
#
# source://prism//lib/prism/dot_visitor.rb#60
def edges; end
# source://prism//lib/prism/dot_visitor.rb#68
def node(value); end
# Returns the value of attribute nodes.
#
# source://prism//lib/prism/dot_visitor.rb#60
def nodes; end
# source://prism//lib/prism/dot_visitor.rb#80
def to_dot; end
# source://prism//lib/prism/dot_visitor.rb#72
def waypoint(value); end
# Returns the value of attribute waypoints.
#
# source://prism//lib/prism/dot_visitor.rb#60
def waypoints; end
end
# source://prism//lib/prism/dot_visitor.rb#15
class Prism::DotVisitor::Field
# @return [Field] a new instance of Field
#
# source://prism//lib/prism/dot_visitor.rb#18
def initialize(name, value, port); end
# Returns the value of attribute name.
#
# source://prism//lib/prism/dot_visitor.rb#16
def name; end
# Returns the value of attribute port.
#
# source://prism//lib/prism/dot_visitor.rb#16
def port; end
# source://prism//lib/prism/dot_visitor.rb#24
def to_dot; end
# Returns the value of attribute value.
#
# source://prism//lib/prism/dot_visitor.rb#16
def value; end
end
# source://prism//lib/prism/dot_visitor.rb#33
class Prism::DotVisitor::Table
# @return [Table] a new instance of Table
#
# source://prism//lib/prism/dot_visitor.rb#36
def initialize(name); end
# source://prism//lib/prism/dot_visitor.rb#41
def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end
# Returns the value of attribute fields.
#
# source://prism//lib/prism/dot_visitor.rb#34
def fields; end
# Returns the value of attribute name.
#
# source://prism//lib/prism/dot_visitor.rb#34
def name; end
# source://prism//lib/prism/dot_visitor.rb#45
def to_dot; end
end
# Represents an `else` clause in a `case`, `if`, or `unless` statement.
#
# if a then b else c end
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#6173
class Prism::ElseNode < ::Prism::Node
# def initialize: (Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc, Location location) -> void
#
# @return [ElseNode] a new instance of ElseNode
#
# source://prism//lib/prism/node.rb#6175
sig do
params(
source: Prism::Source,
else_keyword_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, else_keyword_loc, statements, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6286
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6184
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6189
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6201
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6194
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?, ?location: Location) -> ElseNode
#
# source://prism//lib/prism/node.rb#6206
sig do
params(
else_keyword_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::ElseNode)
end
def copy(else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6189
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#6214
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def else_keyword: () -> String
#
# source://prism//lib/prism/node.rb#6242
sig { returns(String) }
def else_keyword; end
# attr_reader else_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#6219
sig { returns(Prism::Location) }
def else_keyword_loc; end
# def end_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#6247
sig { returns(T.nilable(String)) }
def end_keyword; end
# attr_reader end_keyword_loc: Location?
#
# source://prism//lib/prism/node.rb#6229
sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6252
sig { override.returns(String) }
def inspect; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#6226
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6270
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6280
def type; end
end
end
# EmbDocComment objects correspond to comments that are surrounded by =begin
# and =end.
#
# source://prism//lib/prism/parse_result.rb#403
class Prism::EmbDocComment < ::Prism::Comment
# Returns a string representation of this comment.
#
# source://prism//lib/prism/parse_result.rb#410
sig { returns(String) }
def inspect; end
# This can only be true for inline comments.
#
# @return [Boolean]
#
# source://prism//lib/prism/parse_result.rb#405
sig { override.returns(T::Boolean) }
def trailing?; end
end
# Represents an interpolated set of statements.
#
# "foo #{bar}"
# ^^^^^^
#
# source://prism//lib/prism/node.rb#6298
class Prism::EmbeddedStatementsNode < ::Prism::Node
# def initialize: (Location opening_loc, StatementsNode? statements, Location closing_loc, Location location) -> void
#
# @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode
#
# source://prism//lib/prism/node.rb#6300
sig do
params(
source: Prism::Source,
opening_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, opening_loc, statements, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6405
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6309
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6314
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#6366
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#6354
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6326
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6319
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location, ?location: Location) -> EmbeddedStatementsNode
#
# source://prism//lib/prism/node.rb#6331
sig do
params(
opening_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::EmbeddedStatementsNode)
end
def copy(opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6314
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#6339
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6371
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#6361
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#6344
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#6351
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6389
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6399
def type; end
end
end
# Represents an interpolated variable.
#
# "foo #@bar"
# ^^^^^
#
# source://prism//lib/prism/node.rb#6417
class Prism::EmbeddedVariableNode < ::Prism::Node
# def initialize: (Location operator_loc, Prism::node variable, Location location) -> void
#
# @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode
#
# source://prism//lib/prism/node.rb#6419
sig do
params(
source: Prism::Source,
operator_loc: Prism::Location,
variable: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, operator_loc, variable, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6509
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6427
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6432
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6442
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6437
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?operator_loc: Location, ?variable: Prism::node, ?location: Location) -> EmbeddedVariableNode
#
# source://prism//lib/prism/node.rb#6447
sig do
params(
operator_loc: Prism::Location,
variable: Prism::Node,
location: Prism::Location
).returns(Prism::EmbeddedVariableNode)
end
def copy(operator_loc: T.unsafe(nil), variable: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6432
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, variable: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#6455
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6475
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#6470
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#6460
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6493
sig { override.returns(Symbol) }
def type; end
# attr_reader variable: Prism::node
#
# source://prism//lib/prism/node.rb#6467
sig { returns(Prism::Node) }
def variable; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6503
def type; end
end
end
# Flags for nodes that have unescaped content.
#
# source://prism//lib/prism/node.rb#19157
module Prism::EncodingFlags; end
# internal bytes forced the encoding to binary
#
# source://prism//lib/prism/node.rb#19162
Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to UTF-8
#
# source://prism//lib/prism/node.rb#19159
Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
# Represents an `ensure` clause in a `begin` statement.
#
# begin
# foo
# ensure
# ^^^^^^
# bar
# end
#
# source://prism//lib/prism/node.rb#6524
class Prism::EnsureNode < ::Prism::Node
# def initialize: (Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc, Location location) -> void
#
# @return [EnsureNode] a new instance of EnsureNode
#
# source://prism//lib/prism/node.rb#6526
sig do
params(
source: Prism::Source,
ensure_keyword_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
end_keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, ensure_keyword_loc, statements, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6631
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6535
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6540
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6552
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6545
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location, ?location: Location) -> EnsureNode
#
# source://prism//lib/prism/node.rb#6557
sig do
params(
ensure_keyword_loc: Prism::Location,
statements: T.nilable(Prism::StatementsNode),
end_keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::EnsureNode)
end
def copy(ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6540
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#6565
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#6592
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#6580
sig { returns(Prism::Location) }
def end_keyword_loc; end
# def ensure_keyword: () -> String
#
# source://prism//lib/prism/node.rb#6587
sig { returns(String) }
def ensure_keyword; end
# attr_reader ensure_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#6570
sig { returns(Prism::Location) }
def ensure_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6597
sig { override.returns(String) }
def inspect; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#6577
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6615
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6625
def type; end
end
end
# Represents the use of the literal `false` keyword.
#
# false
# ^^^^^
#
# source://prism//lib/prism/node.rb#6643
class Prism::FalseNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [FalseNode] a new instance of FalseNode
#
# source://prism//lib/prism/node.rb#6645
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6718
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6651
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6656
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6666
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6661
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> FalseNode
#
# source://prism//lib/prism/node.rb#6671
sig { params(location: Prism::Location).returns(Prism::FalseNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6656
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#6679
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6684
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6702
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6712
def type; end
end
end
# Represents a find pattern in pattern matching.
#
# foo in *bar, baz, *qux
# ^^^^^^^^^^^^^^^
#
# foo in [*bar, baz, *qux]
# ^^^^^^^^^^^^^^^^^
#
# foo in Foo(*bar, baz, *qux)
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#6733
class Prism::FindPatternNode < ::Prism::Node
# def initialize: (Prism::node? constant, Prism::node left, Array[Prism::node] requireds, Prism::node right, Location? opening_loc, Location? closing_loc, Location location) -> void
#
# @return [FindPatternNode] a new instance of FindPatternNode
#
# source://prism//lib/prism/node.rb#6735
sig do
params(
source: Prism::Source,
constant: T.nilable(Prism::Node),
left: Prism::Node,
requireds: T::Array[Prism::Node],
right: Prism::Node,
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, constant, left, requireds, right, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6867
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6747
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6752
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#6828
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#6810
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6767
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6757
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader constant: Prism::node?
#
# source://prism//lib/prism/node.rb#6785
sig { returns(T.nilable(Prism::Node)) }
def constant; end
# def copy: (?constant: Prism::node?, ?left: Prism::node, ?requireds: Array[Prism::node], ?right: Prism::node, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> FindPatternNode
#
# source://prism//lib/prism/node.rb#6772
sig do
params(
constant: T.nilable(Prism::Node),
left: Prism::Node,
requireds: T::Array[Prism::Node],
right: Prism::Node,
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::FindPatternNode)
end
def copy(constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6752
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, left: Prism::node, requireds: Array[Prism::node], right: Prism::node, opening_loc: Location?, closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#6780
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6833
sig { override.returns(String) }
def inspect; end
# attr_reader left: Prism::node
#
# source://prism//lib/prism/node.rb#6788
sig { returns(Prism::Node) }
def left; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#6823
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#6797
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader requireds: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#6791
sig { returns(T::Array[Prism::Node]) }
def requireds; end
# attr_reader right: Prism::node
#
# source://prism//lib/prism/node.rb#6794
sig { returns(Prism::Node) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6851
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6861
def type; end
end
end
# Represents the use of the `..` or `...` operators to create flip flops.
#
# baz if foo .. bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#6883
class Prism::FlipFlopNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
#
# @return [FlipFlopNode] a new instance of FlipFlopNode
#
# source://prism//lib/prism/node.rb#6885
sig do
params(
source: Prism::Source,
flags: Integer,
left: T.nilable(Prism::Node),
right: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, left, right, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#6992
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#6895
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6900
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#6913
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#6905
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> FlipFlopNode
#
# source://prism//lib/prism/node.rb#6918
sig do
params(
flags: Integer,
left: T.nilable(Prism::Node),
right: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::FlipFlopNode)
end
def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#6900
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#6926
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def exclude_end?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#6948
sig { returns(T::Boolean) }
def exclude_end?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#6958
sig { override.returns(String) }
def inspect; end
# attr_reader left: Prism::node?
#
# source://prism//lib/prism/node.rb#6935
sig { returns(T.nilable(Prism::Node)) }
def left; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#6953
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#6941
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader right: Prism::node?
#
# source://prism//lib/prism/node.rb#6938
sig { returns(T.nilable(Prism::Node)) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6976
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#6931
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#6986
def type; end
end
end
# Represents a floating point number literal.
#
# 1.0
# ^^^
#
# source://prism//lib/prism/node.rb#7005
class Prism::FloatNode < ::Prism::Node
# def initialize: (Float value, Location location) -> void
#
# @return [FloatNode] a new instance of FloatNode
#
# source://prism//lib/prism/node.rb#7007
sig { params(source: Prism::Source, value: Float, location: Prism::Location).void }
def initialize(source, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7084
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7014
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7019
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7029
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7024
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Float, ?location: Location) -> FloatNode
#
# source://prism//lib/prism/node.rb#7034
sig { params(value: Float, location: Prism::Location).returns(Prism::FloatNode) }
def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7019
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Float, location: Location }
#
# source://prism//lib/prism/node.rb#7042
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7050
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7068
sig { override.returns(Symbol) }
def type; end
# The value of the floating point number as a Float.
#
# source://prism//lib/prism/node.rb#7047
sig { returns(Float) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7078
def type; end
end
end
# Represents the use of the `for` keyword.
#
# for i in a end
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#7094
class Prism::ForNode < ::Prism::Node
# def initialize: (Prism::node index, Prism::node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc, Location location) -> void
#
# @return [ForNode] a new instance of ForNode
#
# source://prism//lib/prism/node.rb#7096
sig do
params(
source: Prism::Source,
index: Prism::Node,
collection: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
for_keyword_loc: Prism::Location,
in_keyword_loc: Prism::Location,
do_keyword_loc: T.nilable(Prism::Location),
end_keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7266
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7109
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7114
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# The collection to iterate over.
#
# for i in a end
# ^
#
# source://prism//lib/prism/node.rb#7155
sig { returns(Prism::Node) }
def collection; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7128
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7119
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?index: Prism::node, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location, ?location: Location) -> ForNode
#
# source://prism//lib/prism/node.rb#7133
sig do
params(
index: Prism::Node,
collection: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
for_keyword_loc: Prism::Location,
in_keyword_loc: Prism::Location,
do_keyword_loc: T.nilable(Prism::Location),
end_keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ForNode)
end
def copy(index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7114
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { index: Prism::node, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#7141
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def do_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#7222
sig { returns(T.nilable(String)) }
def do_keyword; end
# The location of the `do` keyword, if present.
#
# for i in a do end
# ^^
#
# source://prism//lib/prism/node.rb#7189
sig { returns(T.nilable(Prism::Location)) }
def do_keyword_loc; end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#7227
sig { returns(String) }
def end_keyword; end
# The location of the `end` keyword.
#
# for i in a end
# ^^^
#
# source://prism//lib/prism/node.rb#7205
sig { returns(Prism::Location) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def for_keyword: () -> String
#
# source://prism//lib/prism/node.rb#7212
sig { returns(String) }
def for_keyword; end
# The location of the `for` keyword.
#
# for i in a end
# ^^^
#
# source://prism//lib/prism/node.rb#7169
sig { returns(Prism::Location) }
def for_keyword_loc; end
# def in_keyword: () -> String
#
# source://prism//lib/prism/node.rb#7217
sig { returns(String) }
def in_keyword; end
# The location of the `in` keyword.
#
# for i in a end
# ^^
#
# source://prism//lib/prism/node.rb#7179
sig { returns(Prism::Location) }
def in_keyword_loc; end
# The index expression for `for` loops.
#
# for i in a end
# ^
#
# source://prism//lib/prism/node.rb#7149
sig { returns(Prism::Node) }
def index; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7232
sig { override.returns(String) }
def inspect; end
# Represents the body of statements to execute for each iteration of the loop.
#
# for i in a
# foo(i)
# ^^^^^^
# end
#
# source://prism//lib/prism/node.rb#7163
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7250
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7260
def type; end
end
end
# Represents forwarding all arguments to this method to another method.
#
# def foo(...)
# bar(...)
# ^^^
# end
#
# source://prism//lib/prism/node.rb#7284
class Prism::ForwardingArgumentsNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode
#
# source://prism//lib/prism/node.rb#7286
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7359
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7292
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7297
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7307
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7302
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> ForwardingArgumentsNode
#
# source://prism//lib/prism/node.rb#7312
sig { params(location: Prism::Location).returns(Prism::ForwardingArgumentsNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7297
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#7320
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7325
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7343
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7353
def type; end
end
end
# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
#
# def foo(...)
# ^^^
# end
#
# source://prism//lib/prism/node.rb#7369
class Prism::ForwardingParameterNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [ForwardingParameterNode] a new instance of ForwardingParameterNode
#
# source://prism//lib/prism/node.rb#7371
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7444
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7377
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7382
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7392
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7387
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> ForwardingParameterNode
#
# source://prism//lib/prism/node.rb#7397
sig { params(location: Prism::Location).returns(Prism::ForwardingParameterNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7382
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#7405
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7410
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7428
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7438
def type; end
end
end
# Represents the use of the `super` keyword without parentheses or arguments.
#
# super
# ^^^^^
#
# source://prism//lib/prism/node.rb#7453
class Prism::ForwardingSuperNode < ::Prism::Node
# def initialize: (BlockNode? block, Location location) -> void
#
# @return [ForwardingSuperNode] a new instance of ForwardingSuperNode
#
# source://prism//lib/prism/node.rb#7455
sig { params(source: Prism::Source, block: T.nilable(Prism::BlockNode), location: Prism::Location).void }
def initialize(source, block, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7534
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7462
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader block: BlockNode?
#
# source://prism//lib/prism/node.rb#7497
sig { returns(T.nilable(Prism::BlockNode)) }
def block; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7467
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7479
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7472
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?block: BlockNode?, ?location: Location) -> ForwardingSuperNode
#
# source://prism//lib/prism/node.rb#7484
sig { params(block: T.nilable(Prism::BlockNode), location: Prism::Location).returns(Prism::ForwardingSuperNode) }
def copy(block: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7467
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { block: BlockNode?, location: Location }
#
# source://prism//lib/prism/node.rb#7492
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7500
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7518
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7528
def type; end
end
end
# Represents the use of the `&&=` operator for assignment to a global variable.
#
# $target &&= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#7544
class Prism::GlobalVariableAndWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#7546
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7648
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7556
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7561
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7571
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7566
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#7576
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::GlobalVariableAndWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7561
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#7584
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#163
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7614
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#7589
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#7592
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#7609
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#7599
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7632
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#7606
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7642
def type; end
end
end
# Represents assigning to a global variable using an operator that isn't `=`.
#
# $target += value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#7661
class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
#
# @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#7663
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7764
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7674
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#7727
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#7717
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7679
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7689
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7684
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#7694
sig do
params(
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).returns(Prism::GlobalVariableOperatorWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7679
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#7702
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#175
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7730
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#7707
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#7710
sig { returns(Prism::Location) }
def name_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#387
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#394
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7748
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#7724
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7758
def type; end
end
end
# Represents the use of the `||=` operator for assignment to a global variable.
#
# $target ||= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#7778
class Prism::GlobalVariableOrWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#7780
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7882
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7790
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7795
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7805
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7800
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#7810
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::GlobalVariableOrWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7795
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#7818
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#169
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7848
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#7823
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#7826
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#7843
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#7833
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7866
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#7840
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7876
def type; end
end
end
# Represents referencing a global variable.
#
# $foo
# ^^^^
#
# source://prism//lib/prism/node.rb#7895
class Prism::GlobalVariableReadNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode
#
# source://prism//lib/prism/node.rb#7897
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#7978
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7904
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7909
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#7919
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#7914
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> GlobalVariableReadNode
#
# source://prism//lib/prism/node.rb#7924
sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableReadNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#7909
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#7932
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#7944
sig { override.returns(String) }
def inspect; end
# The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
#
# $foo # name `:$foo`
#
# $_Test # name `:$_Test`
#
# source://prism//lib/prism/node.rb#7941
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7962
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#7972
def type; end
end
end
# Represents writing to a global variable in a context that doesn't have an explicit value.
#
# $foo, $bar = baz
# ^^^^ ^^^^
#
# source://prism//lib/prism/node.rb#7988
class Prism::GlobalVariableTargetNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode
#
# source://prism//lib/prism/node.rb#7990
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8067
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#7997
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8012
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8007
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> GlobalVariableTargetNode
#
# source://prism//lib/prism/node.rb#8017
sig { params(name: Symbol, location: Prism::Location).returns(Prism::GlobalVariableTargetNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#8025
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8033
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#8030
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8051
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8061
def type; end
end
end
# Represents writing to a global variable.
#
# $foo = 1
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#8077
class Prism::GlobalVariableWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
#
# @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode
#
# source://prism//lib/prism/node.rb#8079
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8197
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8089
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8094
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8104
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8099
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> GlobalVariableWriteNode
#
# source://prism//lib/prism/node.rb#8109
sig do
params(
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::GlobalVariableWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8094
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#8117
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8163
sig { override.returns(String) }
def inspect; end
# The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
#
# $foo = :bar # name `:$foo`
#
# $_Test = 123 # name `:$_Test`
#
# source://prism//lib/prism/node.rb#8126
sig { returns(Symbol) }
def name; end
# The location of the global variable's name.
#
# $foo = :bar
# ^^^^
#
# source://prism//lib/prism/node.rb#8132
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#8158
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# $foo = :bar
# ^
#
# source://prism//lib/prism/node.rb#8151
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8181
sig { override.returns(Symbol) }
def type; end
# The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# $foo = :bar
# ^^^^
#
# $-xyz = 123
# ^^^
#
# source://prism//lib/prism/node.rb#8145
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8191
def type; end
end
end
# Represents a hash literal.
#
# { a => b }
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#8210
class Prism::HashNode < ::Prism::Node
# def initialize: (Location opening_loc, Array[AssocNode | AssocSplatNode] elements, Location closing_loc, Location location) -> void
#
# @return [HashNode] a new instance of HashNode
#
# source://prism//lib/prism/node.rb#8212
sig do
params(
source: Prism::Source,
opening_loc: Prism::Location,
elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, opening_loc, elements, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8327
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8221
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8226
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#8288
sig { returns(String) }
def closing; end
# The location of the closing brace.
#
# { a => b }
# ^
#
# source://prism//lib/prism/node.rb#8276
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8236
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8231
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location, ?location: Location) -> HashNode
#
# source://prism//lib/prism/node.rb#8241
sig do
params(
opening_loc: Prism::Location,
elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::HashNode)
end
def copy(opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8226
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#8249
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
#
# { a: b }
# ^^^^
#
# { **foo }
# ^^^^^
#
# source://prism//lib/prism/node.rb#8270
sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
def elements; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8293
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#8283
sig { returns(String) }
def opening; end
# The location of the opening brace.
#
# { a => b }
# ^
#
# source://prism//lib/prism/node.rb#8257
sig { returns(Prism::Location) }
def opening_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8311
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8321
def type; end
end
end
# Represents a hash pattern in pattern matching.
#
# foo => { a: 1, b: 2 }
# ^^^^^^^^^^^^^^
#
# foo => { a: 1, b: 2, **c }
# ^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#8343
class Prism::HashPatternNode < ::Prism::Node
# def initialize: (Prism::node? constant, Array[AssocNode] elements, AssocSplatNode | NoKeywordsParameterNode | nil rest, Location? opening_loc, Location? closing_loc, Location location) -> void
#
# @return [HashPatternNode] a new instance of HashPatternNode
#
# source://prism//lib/prism/node.rb#8345
sig do
params(
source: Prism::Source,
constant: T.nilable(Prism::Node),
elements: T::Array[Prism::AssocNode],
rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, constant, elements, rest, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8472
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8356
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8361
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#8433
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#8415
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8375
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8366
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader constant: Prism::node?
#
# source://prism//lib/prism/node.rb#8393
sig { returns(T.nilable(Prism::Node)) }
def constant; end
# def copy: (?constant: Prism::node?, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> HashPatternNode
#
# source://prism//lib/prism/node.rb#8380
sig do
params(
constant: T.nilable(Prism::Node),
elements: T::Array[Prism::AssocNode],
rest: T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode)),
opening_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::HashPatternNode)
end
def copy(constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8361
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#8388
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader elements: Array[AssocNode]
#
# source://prism//lib/prism/node.rb#8396
sig { returns(T::Array[Prism::AssocNode]) }
def elements; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8438
sig { override.returns(String) }
def inspect; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#8428
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#8402
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
#
# source://prism//lib/prism/node.rb#8399
sig { returns(T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode))) }
def rest; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8456
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8466
def type; end
end
end
# source://prism//lib/prism/node_ext.rb#49
module Prism::HeredocQuery
# Returns true if this node was represented as a heredoc in the source code.
#
# @return [Boolean]
#
# source://prism//lib/prism/node_ext.rb#51
def heredoc?; end
end
# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
#
# bar if foo
# ^^^^^^^^^^
#
# if foo then bar end
# ^^^^^^^^^^^^^^^^^^^
#
# foo ? bar : baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#8493
class Prism::IfNode < ::Prism::Node
# def initialize: (Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, Prism::node? consequent, Location? end_keyword_loc, Location location) -> void
#
# @return [IfNode] a new instance of IfNode
#
# source://prism//lib/prism/node.rb#8495
sig do
params(
source: Prism::Source,
if_keyword_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::Node),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8687
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8507
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8512
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8526
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8517
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
#
# if foo
# bar
# elsif baz
# ^^^^^^^^^
# qux
# ^^^
# end
# ^^^
#
# if foo then bar else baz end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#8617
sig { returns(T.nilable(Prism::Node)) }
def consequent; end
# def copy: (?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: Prism::node?, ?end_keyword_loc: Location?, ?location: Location) -> IfNode
#
# source://prism//lib/prism/node.rb#8531
sig do
params(
if_keyword_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::Node),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::IfNode)
end
def copy(if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8512
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Prism::node?, end_keyword_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#8539
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#8648
sig { returns(T.nilable(String)) }
def end_keyword; end
# The location of the `end` keyword if present, `nil` otherwise.
#
# if foo
# bar
# end
# ^^^
#
# source://prism//lib/prism/node.rb#8625
sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def if_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#8638
sig { returns(T.nilable(String)) }
def if_keyword; end
# The location of the `if` keyword if present.
#
# bar if foo
# ^^
#
# The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
#
# source://prism//lib/prism/node.rb#8549
sig { returns(T.nilable(Prism::Location)) }
def if_keyword_loc; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8653
sig { override.returns(String) }
def inspect; end
# source://prism//lib/prism/parse_result/newlines.rb#91
def newline!(lines); end
# The node for the condition the `IfNode` is testing.
#
# if foo
# ^^^
# bar
# end
#
# bar if foo
# ^^^
#
# foo ? bar : baz
# ^^^
#
# source://prism//lib/prism/node.rb#8573
sig { returns(Prism::Node) }
def predicate; end
# Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
#
# if foo
# bar
# ^^^
# baz
# ^^^
# end
#
# source://prism//lib/prism/node.rb#8602
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# def then_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#8643
sig { returns(T.nilable(String)) }
def then_keyword; end
# The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
#
# if foo then bar end
# ^^^^
#
# a ? b : c
# ^
#
# source://prism//lib/prism/node.rb#8582
sig { returns(T.nilable(Prism::Location)) }
def then_keyword_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8671
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8681
def type; end
end
end
# Represents an imaginary number literal.
#
# 1.0i
# ^^^^
#
# source://prism//lib/prism/node.rb#8702
class Prism::ImaginaryNode < ::Prism::Node
# def initialize: (FloatNode | IntegerNode | RationalNode numeric, Location location) -> void
#
# @return [ImaginaryNode] a new instance of ImaginaryNode
#
# source://prism//lib/prism/node.rb#8704
sig do
params(
source: Prism::Source,
numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode),
location: Prism::Location
).void
end
def initialize(source, numeric, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8781
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8711
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8716
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8726
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8721
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?numeric: FloatNode | IntegerNode | RationalNode, ?location: Location) -> ImaginaryNode
#
# source://prism//lib/prism/node.rb#8731
sig do
params(
numeric: T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode),
location: Prism::Location
).returns(Prism::ImaginaryNode)
end
def copy(numeric: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8716
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { numeric: FloatNode | IntegerNode | RationalNode, location: Location }
#
# source://prism//lib/prism/node.rb#8739
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8747
sig { override.returns(String) }
def inspect; end
# attr_reader numeric: FloatNode | IntegerNode | RationalNode
#
# source://prism//lib/prism/node.rb#8744
sig { returns(T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)) }
def numeric; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8765
sig { override.returns(Symbol) }
def type; end
# Returns the value of the node as a Ruby Complex.
#
# source://prism//lib/prism/node_ext.rb#101
sig { returns(Complex) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8775
def type; end
end
end
# Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
#
# { foo: }
# ^^^^
#
# { Foo: }
# ^^^^
#
# foo in { bar: }
# ^^^^
#
# source://prism//lib/prism/node.rb#8797
class Prism::ImplicitNode < ::Prism::Node
# def initialize: (Prism::node value, Location location) -> void
#
# @return [ImplicitNode] a new instance of ImplicitNode
#
# source://prism//lib/prism/node.rb#8799
sig { params(source: Prism::Source, value: Prism::Node, location: Prism::Location).void }
def initialize(source, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8876
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8806
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8811
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8821
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8816
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Prism::node, ?location: Location) -> ImplicitNode
#
# source://prism//lib/prism/node.rb#8826
sig { params(value: Prism::Node, location: Prism::Location).returns(Prism::ImplicitNode) }
def copy(value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8811
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#8834
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8842
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8860
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#8839
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8870
def type; end
end
end
# Represents using a trailing comma to indicate an implicit rest parameter.
#
# foo { |bar,| }
# ^
#
# foo in [bar,]
# ^
#
# for foo, in bar do end
# ^
#
# foo, = bar
# ^
#
# source://prism//lib/prism/node.rb#8895
class Prism::ImplicitRestNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [ImplicitRestNode] a new instance of ImplicitRestNode
#
# source://prism//lib/prism/node.rb#8897
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#8970
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8903
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8908
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#8918
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#8913
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> ImplicitRestNode
#
# source://prism//lib/prism/node.rb#8923
sig { params(location: Prism::Location).returns(Prism::ImplicitRestNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8908
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#8931
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#8936
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8954
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#8964
def type; end
end
end
# Represents the use of the `in` keyword in a case statement.
#
# case a; in b then c end
# ^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#8979
class Prism::InNode < ::Prism::Node
# def initialize: (Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc, Location location) -> void
#
# @return [InNode] a new instance of InNode
#
# source://prism//lib/prism/node.rb#8981
sig do
params(
source: Prism::Source,
pattern: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
in_loc: Prism::Location,
then_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, pattern, statements, in_loc, then_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9097
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#8991
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8996
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9009
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9001
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?, ?location: Location) -> InNode
#
# source://prism//lib/prism/node.rb#9014
sig do
params(
pattern: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
in_loc: Prism::Location,
then_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::InNode)
end
def copy(pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#8996
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#9022
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def in: () -> String
#
# source://prism//lib/prism/node.rb#9053
sig { returns(String) }
def in; end
# attr_reader in_loc: Location
#
# source://prism//lib/prism/node.rb#9033
sig { returns(Prism::Location) }
def in_loc; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9063
sig { override.returns(String) }
def inspect; end
# attr_reader pattern: Prism::node
#
# source://prism//lib/prism/node.rb#9027
sig { returns(Prism::Node) }
def pattern; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#9030
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# def then: () -> String?
#
# source://prism//lib/prism/node.rb#9058
sig { returns(T.nilable(String)) }
def then; end
# attr_reader then_loc: Location?
#
# source://prism//lib/prism/node.rb#9040
sig { returns(T.nilable(Prism::Location)) }
def then_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9081
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9091
def type; end
end
end
# Represents the use of the `&&=` operator on a call to the `[]` method.
#
# foo.bar[baz] &&= value
# ^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#9110
class Prism::IndexAndWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [IndexAndWriteNode] a new instance of IndexAndWriteNode
#
# source://prism//lib/prism/node.rb#9112
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9289
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9127
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#9192
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9225
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#9202
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#9235
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#9172
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9132
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#9245
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#9195
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9147
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9137
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexAndWriteNode
#
# source://prism//lib/prism/node.rb#9152
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::IndexAndWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9132
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#9160
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9230
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9255
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#9240
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#9185
sig { returns(Prism::Location) }
def opening_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#9250
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#9205
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#9169
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9215
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9273
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#9212
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9220
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#9165
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9283
def type; end
end
end
# Represents the use of an assignment operator on a call to `[]`.
#
# foo.bar[baz] += value
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#9307
class Prism::IndexOperatorWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
#
# @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode
#
# source://prism//lib/prism/node.rb#9309
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
binary_operator: Symbol,
binary_operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9485
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9325
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#9390
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9426
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#9403
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#9406
sig { returns(Prism::Location) }
def binary_operator_loc; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#9400
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#9436
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#9370
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9330
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#9446
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#9393
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9345
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9335
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
#
# source://prism//lib/prism/node.rb#9350
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
binary_operator: Symbol,
binary_operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::IndexOperatorWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9330
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#9358
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9431
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9451
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#9441
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#9383
sig { returns(Prism::Location) }
def opening_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#403
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#410
def operator_loc; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#9367
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9416
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9469
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#9413
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9421
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#9363
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9479
def type; end
end
end
# Represents the use of the `||=` operator on a call to `[]`.
#
# foo.bar[baz] ||= value
# ^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#9504
class Prism::IndexOrWriteNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [IndexOrWriteNode] a new instance of IndexOrWriteNode
#
# source://prism//lib/prism/node.rb#9506
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9683
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9521
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#9586
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9619
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#9596
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def call_operator: () -> String?
#
# source://prism//lib/prism/node.rb#9629
sig { returns(T.nilable(String)) }
def call_operator; end
# attr_reader call_operator_loc: Location?
#
# source://prism//lib/prism/node.rb#9566
sig { returns(T.nilable(Prism::Location)) }
def call_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9526
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#9639
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#9589
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9541
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9531
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOrWriteNode
#
# source://prism//lib/prism/node.rb#9546
sig do
params(
flags: Integer,
receiver: T.nilable(Prism::Node),
call_operator_loc: T.nilable(Prism::Location),
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::IndexOrWriteNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9526
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#9554
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9624
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9649
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#9634
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#9579
sig { returns(Prism::Location) }
def opening_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#9644
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#9599
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader receiver: Prism::node?
#
# source://prism//lib/prism/node.rb#9563
sig { returns(T.nilable(Prism::Node)) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9609
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9667
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#9606
sig { returns(Prism::Node) }
def value; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9614
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#9559
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9677
def type; end
end
end
# Represents assigning to an index.
#
# foo[bar], = 1
# ^^^^^^^^
#
# begin
# rescue => foo[bar]
# ^^^^^^^^
# end
#
# for foo[bar] in baz do end
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#9709
class Prism::IndexTargetNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location location) -> void
#
# @return [IndexTargetNode] a new instance of IndexTargetNode
#
# source://prism//lib/prism/node.rb#9711
sig do
params(
source: Prism::Source,
flags: Integer,
receiver: Prism::Node,
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
location: Prism::Location
).void
end
def initialize(source, flags, receiver, opening_loc, arguments, closing_loc, block, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9851
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9723
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#9774
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def attribute_write?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9797
sig { returns(T::Boolean) }
def attribute_write?; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#9784
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9728
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#9812
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#9777
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9742
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9733
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?location: Location) -> IndexTargetNode
#
# source://prism//lib/prism/node.rb#9747
sig do
params(
flags: Integer,
receiver: Prism::Node,
opening_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
closing_loc: Prism::Location,
block: T.nilable(Prism::Node),
location: Prism::Location
).returns(Prism::IndexTargetNode)
end
def copy(flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9728
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, location: Location }
#
# source://prism//lib/prism/node.rb#9755
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def ignore_visibility?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9802
sig { returns(T::Boolean) }
def ignore_visibility?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9817
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#9807
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#9767
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader receiver: Prism::node
#
# source://prism//lib/prism/node.rb#9764
sig { returns(Prism::Node) }
def receiver; end
# def safe_navigation?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9787
sig { returns(T::Boolean) }
def safe_navigation?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9835
sig { override.returns(Symbol) }
def type; end
# def variable_call?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#9792
sig { returns(T::Boolean) }
def variable_call?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#9760
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9845
def type; end
end
end
# InlineComment objects are the most common. They correspond to comments in
# the source file like this one that start with #.
#
# source://prism//lib/prism/parse_result.rb#388
class Prism::InlineComment < ::Prism::Comment
# Returns a string representation of this comment.
#
# source://prism//lib/prism/parse_result.rb#396
sig { returns(String) }
def inspect; end
# Returns true if this comment happens on the same line as other code and
# false if the comment is by itself.
#
# @return [Boolean]
#
# source://prism//lib/prism/parse_result.rb#391
sig { override.returns(T::Boolean) }
def trailing?; end
end
# This visitor is responsible for composing the strings that get returned by
# the various #inspect methods defined on each of the nodes.
#
# source://prism//lib/prism/inspect_visitor.rb#12
class Prism::InspectVisitor < ::Prism::Visitor
# Initializes a new instance of the InspectVisitor.
#
# @return [InspectVisitor] a new instance of InspectVisitor
#
# source://prism//lib/prism/inspect_visitor.rb#35
sig { params(indent: String).void }
def initialize(indent = T.unsafe(nil)); end
# The list of commands that we need to execute in order to compose the
# final string.
#
# source://prism//lib/prism/inspect_visitor.rb#32
def commands; end
# Compose the final string.
#
# source://prism//lib/prism/inspect_visitor.rb#48
sig { returns(String) }
def compose; end
# The current prefix string.
#
# source://prism//lib/prism/inspect_visitor.rb#28
def indent; end
# Inspect a AliasGlobalVariableNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#77
def visit_alias_global_variable_node(node); end
# Inspect a AliasMethodNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#87
def visit_alias_method_node(node); end
# Inspect a AlternationPatternNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#97
def visit_alternation_pattern_node(node); end
# Inspect a AndNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#107
def visit_and_node(node); end
# Inspect a ArgumentsNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#117
def visit_arguments_node(node); end
# Inspect a ArrayNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#133
def visit_array_node(node); end
# Inspect a ArrayPatternNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#151
def visit_array_pattern_node(node); end
# Inspect a AssocNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#188
def visit_assoc_node(node); end
# Inspect a AssocSplatNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#198
def visit_assoc_splat_node(node); end
# Inspect a BackReferenceReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#210
def visit_back_reference_read_node(node); end
# Inspect a BeginNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#216
def visit_begin_node(node); end
# Inspect a BlockArgumentNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#247
def visit_block_argument_node(node); end
# Inspect a BlockLocalVariableNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#259
def visit_block_local_variable_node(node); end
# Inspect a BlockNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#267
def visit_block_node(node); end
# Inspect a BlockParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#287
def visit_block_parameter_node(node); end
# Inspect a BlockParametersNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#301
def visit_block_parameters_node(node); end
# Inspect a BreakNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#323
def visit_break_node(node); end
# Inspect a CallAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#335
def visit_call_and_write_node(node); end
# Inspect a CallNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#355
def visit_call_node(node); end
# Inspect a CallOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#385
def visit_call_operator_write_node(node); end
# Inspect a CallOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#406
def visit_call_or_write_node(node); end
# Inspect a CallTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#426
def visit_call_target_node(node); end
# Inspect a CapturePatternNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#438
def visit_capture_pattern_node(node); end
# Inspect a CaseMatchNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#448
def visit_case_match_node(node); end
# Inspect a CaseNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#476
def visit_case_node(node); end
# Inspect a ClassNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#504
def visit_class_node(node); end
# Inspect a ClassVariableAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#528
def visit_class_variable_and_write_node(node); end
# Inspect a ClassVariableOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#538
def visit_class_variable_operator_write_node(node); end
# Inspect a ClassVariableOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#549
def visit_class_variable_or_write_node(node); end
# Inspect a ClassVariableReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#559
def visit_class_variable_read_node(node); end
# Inspect a ClassVariableTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#565
def visit_class_variable_target_node(node); end
# Inspect a ClassVariableWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#571
def visit_class_variable_write_node(node); end
# Inspect a ConstantAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#581
def visit_constant_and_write_node(node); end
# Inspect a ConstantOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#591
def visit_constant_operator_write_node(node); end
# Inspect a ConstantOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#602
def visit_constant_or_write_node(node); end
# Inspect a ConstantPathAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#612
def visit_constant_path_and_write_node(node); end
# Inspect a ConstantPathNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#622
def visit_constant_path_node(node); end
# Inspect a ConstantPathOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#640
def visit_constant_path_operator_write_node(node); end
# Inspect a ConstantPathOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#651
def visit_constant_path_or_write_node(node); end
# Inspect a ConstantPathTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#661
def visit_constant_path_target_node(node); end
# Inspect a ConstantPathWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#679
def visit_constant_path_write_node(node); end
# Inspect a ConstantReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#689
def visit_constant_read_node(node); end
# Inspect a ConstantTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#695
def visit_constant_target_node(node); end
# Inspect a ConstantWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#701
def visit_constant_write_node(node); end
# Inspect a DefNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#711
def visit_def_node(node); end
# Inspect a DefinedNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#743
def visit_defined_node(node); end
# Inspect a ElseNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#753
def visit_else_node(node); end
# Inspect a EmbeddedStatementsNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#766
def visit_embedded_statements_node(node); end
# Inspect a EmbeddedVariableNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#779
def visit_embedded_variable_node(node); end
# Inspect a EnsureNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#787
def visit_ensure_node(node); end
# Inspect a FalseNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#800
def visit_false_node(node); end
# Inspect a FindPatternNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#805
def visit_find_pattern_node(node); end
# Inspect a FlipFlopNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#831
def visit_flip_flop_node(node); end
# Inspect a FloatNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#851
def visit_float_node(node); end
# Inspect a ForNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#857
def visit_for_node(node); end
# Inspect a ForwardingArgumentsNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#876
def visit_forwarding_arguments_node(node); end
# Inspect a ForwardingParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#881
def visit_forwarding_parameter_node(node); end
# Inspect a ForwardingSuperNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#886
def visit_forwarding_super_node(node); end
# Inspect a GlobalVariableAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#897
def visit_global_variable_and_write_node(node); end
# Inspect a GlobalVariableOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#907
def visit_global_variable_operator_write_node(node); end
# Inspect a GlobalVariableOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#918
def visit_global_variable_or_write_node(node); end
# Inspect a GlobalVariableReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#928
def visit_global_variable_read_node(node); end
# Inspect a GlobalVariableTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#934
def visit_global_variable_target_node(node); end
# Inspect a GlobalVariableWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#940
def visit_global_variable_write_node(node); end
# Inspect a HashNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#950
def visit_hash_node(node); end
# Inspect a HashPatternNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#966
def visit_hash_pattern_node(node); end
# Inspect a IfNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#994
def visit_if_node(node); end
# Inspect a ImaginaryNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1016
def visit_imaginary_node(node); end
# Inspect a ImplicitNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1023
def visit_implicit_node(node); end
# Inspect a ImplicitRestNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1030
def visit_implicit_rest_node(node); end
# Inspect a InNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1035
def visit_in_node(node); end
# Inspect a IndexAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1050
def visit_index_and_write_node(node); end
# Inspect a IndexOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1081
def visit_index_operator_write_node(node); end
# Inspect a IndexOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1113
def visit_index_or_write_node(node); end
# Inspect a IndexTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1144
def visit_index_target_node(node); end
# Inspect a InstanceVariableAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1167
def visit_instance_variable_and_write_node(node); end
# Inspect a InstanceVariableOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1177
def visit_instance_variable_operator_write_node(node); end
# Inspect a InstanceVariableOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1188
def visit_instance_variable_or_write_node(node); end
# Inspect a InstanceVariableReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1198
def visit_instance_variable_read_node(node); end
# Inspect a InstanceVariableTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1204
def visit_instance_variable_target_node(node); end
# Inspect a InstanceVariableWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1210
def visit_instance_variable_write_node(node); end
# Inspect a IntegerNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1220
def visit_integer_node(node); end
# Inspect a InterpolatedMatchLastLineNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1228
def visit_interpolated_match_last_line_node(node); end
# Inspect a InterpolatedRegularExpressionNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1246
def visit_interpolated_regular_expression_node(node); end
# Inspect a InterpolatedStringNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1264
def visit_interpolated_string_node(node); end
# Inspect a InterpolatedSymbolNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1282
def visit_interpolated_symbol_node(node); end
# Inspect a InterpolatedXStringNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1298
def visit_interpolated_x_string_node(node); end
# Inspect a ItLocalVariableReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1314
def visit_it_local_variable_read_node(node); end
# Inspect a ItParametersNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1319
def visit_it_parameters_node(node); end
# Inspect a KeywordHashNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1324
def visit_keyword_hash_node(node); end
# Inspect a KeywordRestParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1340
def visit_keyword_rest_parameter_node(node); end
# Inspect a LambdaNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1354
def visit_lambda_node(node); end
# Inspect a LocalVariableAndWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1375
def visit_local_variable_and_write_node(node); end
# Inspect a LocalVariableOperatorWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1386
def visit_local_variable_operator_write_node(node); end
# Inspect a LocalVariableOrWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1398
def visit_local_variable_or_write_node(node); end
# Inspect a LocalVariableReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1409
def visit_local_variable_read_node(node); end
# Inspect a LocalVariableTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1416
def visit_local_variable_target_node(node); end
# Inspect a LocalVariableWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1423
def visit_local_variable_write_node(node); end
# Inspect a MatchLastLineNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1434
def visit_match_last_line_node(node); end
# Inspect a MatchPredicateNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1445
def visit_match_predicate_node(node); end
# Inspect a MatchRequiredNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1455
def visit_match_required_node(node); end
# Inspect a MatchWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1465
def visit_match_write_node(node); end
# Inspect a MissingNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1481
def visit_missing_node(node); end
# Inspect a ModuleNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1486
def visit_module_node(node); end
# Inspect a MultiTargetNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1503
def visit_multi_target_node(node); end
# Inspect a MultiWriteNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1534
def visit_multi_write_node(node); end
# Inspect a NextNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1568
def visit_next_node(node); end
# Inspect a NilNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1580
def visit_nil_node(node); end
# Inspect a NoKeywordsParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1585
def visit_no_keywords_parameter_node(node); end
# Inspect a NumberedParametersNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1592
def visit_numbered_parameters_node(node); end
# Inspect a NumberedReferenceReadNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1598
def visit_numbered_reference_read_node(node); end
# Inspect a OptionalKeywordParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1604
def visit_optional_keyword_parameter_node(node); end
# Inspect a OptionalParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1615
def visit_optional_parameter_node(node); end
# Inspect a OrNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1627
def visit_or_node(node); end
# Inspect a ParametersNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1637
def visit_parameters_node(node); end
# Inspect a ParenthesesNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1696
def visit_parentheses_node(node); end
# Inspect a PinnedExpressionNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1709
def visit_pinned_expression_node(node); end
# Inspect a PinnedVariableNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1719
def visit_pinned_variable_node(node); end
# Inspect a PostExecutionNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1727
def visit_post_execution_node(node); end
# Inspect a PreExecutionNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1741
def visit_pre_execution_node(node); end
# Inspect a ProgramNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1755
def visit_program_node(node); end
# Inspect a RangeNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1763
def visit_range_node(node); end
# Inspect a RationalNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1783
def visit_rational_node(node); end
# Inspect a RedoNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1792
def visit_redo_node(node); end
# Inspect a RegularExpressionNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1797
def visit_regular_expression_node(node); end
# Inspect a RequiredKeywordParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1808
def visit_required_keyword_parameter_node(node); end
# Inspect a RequiredParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1817
def visit_required_parameter_node(node); end
# Inspect a RescueModifierNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1825
def visit_rescue_modifier_node(node); end
# Inspect a RescueNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1835
def visit_rescue_node(node); end
# Inspect a RestParameterNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1869
def visit_rest_parameter_node(node); end
# Inspect a RetryNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1883
def visit_retry_node(node); end
# Inspect a ReturnNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1888
def visit_return_node(node); end
# Inspect a SelfNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1902
def visit_self_node(node); end
# Inspect a ShareableConstantNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1907
def visit_shareable_constant_node(node); end
# Inspect a SingletonClassNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1916
def visit_singleton_class_node(node); end
# Inspect a SourceEncodingNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1933
def visit_source_encoding_node(node); end
# Inspect a SourceFileNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1938
def visit_source_file_node(node); end
# Inspect a SourceLineNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1946
def visit_source_line_node(node); end
# Inspect a SplatNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1951
def visit_splat_node(node); end
# Inspect a StatementsNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1963
def visit_statements_node(node); end
# Inspect a StringNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1977
def visit_string_node(node); end
# Inspect a SuperNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#1988
def visit_super_node(node); end
# Inspect a SymbolNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2008
def visit_symbol_node(node); end
# Inspect a TrueNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2019
def visit_true_node(node); end
# Inspect a UndefNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2024
def visit_undef_node(node); end
# Inspect a UnlessNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2039
def visit_unless_node(node); end
# Inspect a UntilNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2061
def visit_until_node(node); end
# Inspect a WhenNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2078
def visit_when_node(node); end
# Inspect a WhileNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2100
def visit_while_node(node); end
# Inspect a XStringNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2117
def visit_x_string_node(node); end
# Inspect a YieldNode node.
#
# source://prism//lib/prism/inspect_visitor.rb#2128
def visit_yield_node(node); end
private
# Compose a string representing the given inner location field.
#
# source://prism//lib/prism/inspect_visitor.rb#2150
def inspect_location(location); end
# Compose a header for the given node.
#
# source://prism//lib/prism/inspect_visitor.rb#2144
def inspect_node(name, node); end
class << self
# Compose an inspect string for the given node.
#
# source://prism//lib/prism/inspect_visitor.rb#41
sig { params(node: Prism::Node).returns(String) }
def compose(node); end
end
end
# Most of the time, we can simply pass down the indent to the next node.
# However, when we are inside a list we want some extra special formatting
# when we hit an element in that list. In this case, we have a special
# command that replaces the subsequent indent with the given value.
#
# source://prism//lib/prism/inspect_visitor.rb#17
class Prism::InspectVisitor::Replace
# @return [Replace] a new instance of Replace
#
# source://prism//lib/prism/inspect_visitor.rb#20
def initialize(value); end
# source://prism//lib/prism/inspect_visitor.rb#18
def value; end
end
# Represents the use of the `&&=` operator for assignment to an instance variable.
#
# @target &&= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#9866
class Prism::InstanceVariableAndWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#9868
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#9970
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9878
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9883
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#9893
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#9888
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#9898
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::InstanceVariableAndWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#9883
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#9906
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#181
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#9936
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#9911
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#9914
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#9931
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#9921
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9954
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#9928
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#9964
def type; end
end
end
# Represents assigning to an instance variable using an operator that isn't `=`.
#
# @target += value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#9983
class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
#
# @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#9985
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10086
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#9996
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#10049
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#10039
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10001
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10011
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10006
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#10016
sig do
params(
name: Symbol,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
binary_operator: Symbol,
location: Prism::Location
).returns(Prism::InstanceVariableOperatorWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10001
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#10024
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#193
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10052
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#10029
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#10032
sig { returns(Prism::Location) }
def name_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#419
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#426
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10070
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#10046
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10080
def type; end
end
end
# Represents the use of the `||=` operator for assignment to an instance variable.
#
# @target ||= value
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#10100
class Prism::InstanceVariableOrWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#10102
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10204
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10112
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10117
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10127
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10122
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#10132
sig do
params(
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::InstanceVariableOrWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10117
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#10140
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# source://prism//lib/prism/desugar_compiler.rb#187
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10170
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#10145
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#10148
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#10165
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#10155
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10188
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#10162
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10198
def type; end
end
end
# Represents referencing an instance variable.
#
# @foo
# ^^^^
#
# source://prism//lib/prism/node.rb#10217
class Prism::InstanceVariableReadNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode
#
# source://prism//lib/prism/node.rb#10219
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10300
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10226
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10231
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10241
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10236
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> InstanceVariableReadNode
#
# source://prism//lib/prism/node.rb#10246
sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableReadNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10231
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#10254
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10266
sig { override.returns(String) }
def inspect; end
# The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# @x # name `:@x`
#
# @_test # name `:@_test`
#
# source://prism//lib/prism/node.rb#10263
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10284
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10294
def type; end
end
end
# Represents writing to an instance variable in a context that doesn't have an explicit value.
#
# @foo, @bar = baz
# ^^^^ ^^^^
#
# source://prism//lib/prism/node.rb#10310
class Prism::InstanceVariableTargetNode < ::Prism::Node
# def initialize: (Symbol name, Location location) -> void
#
# @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode
#
# source://prism//lib/prism/node.rb#10312
sig { params(source: Prism::Source, name: Symbol, location: Prism::Location).void }
def initialize(source, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10389
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10319
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10324
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10334
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10329
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?location: Location) -> InstanceVariableTargetNode
#
# source://prism//lib/prism/node.rb#10339
sig { params(name: Symbol, location: Prism::Location).returns(Prism::InstanceVariableTargetNode) }
def copy(name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10324
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#10347
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10355
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#10352
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10373
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10383
def type; end
end
end
# Represents writing to an instance variable.
#
# @foo = 1
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#10399
class Prism::InstanceVariableWriteNode < ::Prism::Node
# def initialize: (Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
#
# @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode
#
# source://prism//lib/prism/node.rb#10401
sig do
params(
source: Prism::Source,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, name, name_loc, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10519
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10411
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10416
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10426
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10421
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> InstanceVariableWriteNode
#
# source://prism//lib/prism/node.rb#10431
sig do
params(
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::InstanceVariableWriteNode)
end
def copy(name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10416
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#10439
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10485
sig { override.returns(String) }
def inspect; end
# The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# @x = :y # name `:@x`
#
# @_foo = "bar" # name `@_foo`
#
# source://prism//lib/prism/node.rb#10448
sig { returns(Symbol) }
def name; end
# The location of the variable name.
#
# @_x = 1
# ^^^
#
# source://prism//lib/prism/node.rb#10454
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#10480
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# @x = y
# ^
#
# source://prism//lib/prism/node.rb#10473
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10503
sig { override.returns(Symbol) }
def type; end
# The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# @foo = :bar
# ^^^^
#
# @_x = 1234
# ^^^^
#
# source://prism//lib/prism/node.rb#10467
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10513
def type; end
end
end
# Flags for integer nodes that correspond to the base of the integer.
#
# source://prism//lib/prism/node.rb#19166
module Prism::IntegerBaseFlags; end
# 0b prefix
#
# source://prism//lib/prism/node.rb#19168
Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer)
# 0d or no prefix
#
# source://prism//lib/prism/node.rb#19171
Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer)
# 0x prefix
#
# source://prism//lib/prism/node.rb#19177
Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer)
# 0o or 0 prefix
#
# source://prism//lib/prism/node.rb#19174
Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer)
# Represents an integer number literal.
#
# 1
# ^
#
# source://prism//lib/prism/node.rb#10532
class Prism::IntegerNode < ::Prism::Node
# def initialize: (Integer flags, Integer value, Location location) -> void
#
# @return [IntegerNode] a new instance of IntegerNode
#
# source://prism//lib/prism/node.rb#10534
sig { params(source: Prism::Source, flags: Integer, value: Integer, location: Prism::Location).void }
def initialize(source, flags, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10636
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10542
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def binary?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10582
sig { returns(T::Boolean) }
def binary?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10547
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10557
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10552
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?value: Integer, ?location: Location) -> IntegerNode
#
# source://prism//lib/prism/node.rb#10562
sig { params(flags: Integer, value: Integer, location: Prism::Location).returns(Prism::IntegerNode) }
def copy(flags: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def decimal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10587
sig { returns(T::Boolean) }
def decimal?; end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10547
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, value: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#10570
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def hexadecimal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10597
sig { returns(T::Boolean) }
def hexadecimal?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10602
sig { override.returns(String) }
def inspect; end
# def octal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10592
sig { returns(T::Boolean) }
def octal?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10620
sig { override.returns(Symbol) }
def type; end
# The value of the integer literal as a number.
#
# source://prism//lib/prism/node.rb#10579
sig { returns(Integer) }
def value; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#10575
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10630
def type; end
end
end
# Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
#
# if /foo #{bar} baz/ then end
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#10647
class Prism::InterpolatedMatchLastLineNode < ::Prism::Node
include ::Prism::RegularExpressionOptions
# def initialize: (Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
#
# @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode
#
# source://prism//lib/prism/node.rb#10649
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, parts, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10812
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10659
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def ascii_8bit?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10738
sig { returns(T::Boolean) }
def ascii_8bit?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10664
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#10773
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#10706
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10674
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10669
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedMatchLastLineNode
#
# source://prism//lib/prism/node.rb#10679
sig do
params(
flags: Integer,
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::InterpolatedMatchLastLineNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10664
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#10687
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def euc_jp?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10733
sig { returns(T::Boolean) }
def euc_jp?; end
# def extended?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10718
sig { returns(T::Boolean) }
def extended?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10758
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_us_ascii_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10763
sig { returns(T::Boolean) }
def forced_us_ascii_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10753
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def ignore_case?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10713
sig { returns(T::Boolean) }
def ignore_case?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10778
sig { override.returns(String) }
def inspect; end
# def multi_line?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10723
sig { returns(T::Boolean) }
def multi_line?; end
# source://prism//lib/prism/parse_result/newlines.rb#121
def newline!(lines); end
# def once?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10728
sig { returns(T::Boolean) }
def once?; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#10768
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#10696
sig { returns(Prism::Location) }
def opening_loc; end
sig { returns(Integer) }
def options; end
# attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
#
# source://prism//lib/prism/node.rb#10703
sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
def parts; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10796
sig { override.returns(Symbol) }
def type; end
# def utf_8?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10748
sig { returns(T::Boolean) }
def utf_8?; end
# def windows_31j?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10743
sig { returns(T::Boolean) }
def windows_31j?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#10692
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10806
def type; end
end
end
# Represents a regular expression literal that contains interpolation.
#
# /foo #{bar} baz/
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#10826
class Prism::InterpolatedRegularExpressionNode < ::Prism::Node
include ::Prism::RegularExpressionOptions
# def initialize: (Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
#
# @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode
#
# source://prism//lib/prism/node.rb#10828
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, parts, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#10991
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#10838
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def ascii_8bit?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10917
sig { returns(T::Boolean) }
def ascii_8bit?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10843
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#10952
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#10885
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#10853
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#10848
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedRegularExpressionNode
#
# source://prism//lib/prism/node.rb#10858
sig do
params(
flags: Integer,
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::InterpolatedRegularExpressionNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#10843
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#10866
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def euc_jp?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10912
sig { returns(T::Boolean) }
def euc_jp?; end
# def extended?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10897
sig { returns(T::Boolean) }
def extended?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10937
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_us_ascii_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10942
sig { returns(T::Boolean) }
def forced_us_ascii_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10932
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def ignore_case?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10892
sig { returns(T::Boolean) }
def ignore_case?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#10957
sig { override.returns(String) }
def inspect; end
# def multi_line?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10902
sig { returns(T::Boolean) }
def multi_line?; end
# source://prism//lib/prism/parse_result/newlines.rb#128
def newline!(lines); end
# def once?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10907
sig { returns(T::Boolean) }
def once?; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#10947
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#10875
sig { returns(Prism::Location) }
def opening_loc; end
sig { returns(Integer) }
def options; end
# attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
#
# source://prism//lib/prism/node.rb#10882
sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
def parts; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10975
sig { override.returns(Symbol) }
def type; end
# def utf_8?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10927
sig { returns(T::Boolean) }
def utf_8?; end
# def windows_31j?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#10922
sig { returns(T::Boolean) }
def windows_31j?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#10871
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#10985
def type; end
end
end
# Represents a string literal that contains interpolation.
#
# "foo #{bar} baz"
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11005
class Prism::InterpolatedStringNode < ::Prism::Node
include ::Prism::HeredocQuery
# def initialize: (Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode] parts, Location? closing_loc, Location location) -> void
#
# @return [InterpolatedStringNode] a new instance of InterpolatedStringNode
#
# source://prism//lib/prism/node.rb#11007
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: T.nilable(Prism::Location),
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, parts, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11137
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11017
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11022
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#11098
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#11070
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11032
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11027
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedStringNode
#
# source://prism//lib/prism/node.rb#11037
sig do
params(
flags: Integer,
opening_loc: T.nilable(Prism::Location),
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)],
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::InterpolatedStringNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11022
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#11045
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def frozen?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#11083
sig { returns(T::Boolean) }
def frozen?; end
sig { returns(T::Boolean) }
def heredoc?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11103
sig { override.returns(String) }
def inspect; end
# def mutable?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#11088
sig { returns(T::Boolean) }
def mutable?; end
# source://prism//lib/prism/parse_result/newlines.rb#135
def newline!(lines); end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#11093
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#11054
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode]
#
# source://prism//lib/prism/node.rb#11067
sig do
returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode)])
end
def parts; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11121
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#11050
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11131
def type; end
end
end
# Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
#
# source://prism//lib/prism/node.rb#19181
module Prism::InterpolatedStringNodeFlags; end
# source://prism//lib/prism/node.rb#19183
Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer)
# source://prism//lib/prism/node.rb#19186
Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
# Represents a symbol literal that contains interpolation.
#
# :"foo #{bar} baz"
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11151
class Prism::InterpolatedSymbolNode < ::Prism::Node
# def initialize: (Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location? closing_loc, Location location) -> void
#
# @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode
#
# source://prism//lib/prism/node.rb#11153
sig do
params(
source: Prism::Source,
opening_loc: T.nilable(Prism::Location),
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, opening_loc, parts, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11268
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11162
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11167
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#11229
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#11211
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11177
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11172
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedSymbolNode
#
# source://prism//lib/prism/node.rb#11182
sig do
params(
opening_loc: T.nilable(Prism::Location),
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::InterpolatedSymbolNode)
end
def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11167
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#11190
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11234
sig { override.returns(String) }
def inspect; end
# source://prism//lib/prism/parse_result/newlines.rb#142
def newline!(lines); end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#11224
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#11195
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
#
# source://prism//lib/prism/node.rb#11208
sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
def parts; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11252
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11262
def type; end
end
end
# Represents an xstring literal that contains interpolation.
#
# `foo #{bar} baz`
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11281
class Prism::InterpolatedXStringNode < ::Prism::Node
include ::Prism::HeredocQuery
# def initialize: (Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
#
# @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode
#
# source://prism//lib/prism/node.rb#11283
sig do
params(
source: Prism::Source,
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, opening_loc, parts, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11386
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11292
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11297
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#11347
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#11335
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11307
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11302
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedXStringNode
#
# source://prism//lib/prism/node.rb#11312
sig do
params(
opening_loc: Prism::Location,
parts: T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)],
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::InterpolatedXStringNode)
end
def copy(opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11297
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#11320
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
sig { returns(T::Boolean) }
def heredoc?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11352
sig { override.returns(String) }
def inspect; end
# source://prism//lib/prism/parse_result/newlines.rb#149
def newline!(lines); end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#11342
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#11325
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
#
# source://prism//lib/prism/node.rb#11332
sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) }
def parts; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11370
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11380
def type; end
end
end
# Represents reading from the implicit `it` local variable.
#
# -> { it }
# ^^
#
# source://prism//lib/prism/node.rb#11399
class Prism::ItLocalVariableReadNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [ItLocalVariableReadNode] a new instance of ItLocalVariableReadNode
#
# source://prism//lib/prism/node.rb#11401
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11474
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11407
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11412
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11422
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11417
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> ItLocalVariableReadNode
#
# source://prism//lib/prism/node.rb#11427
sig { params(location: Prism::Location).returns(Prism::ItLocalVariableReadNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11412
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#11435
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11440
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11458
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11468
def type; end
end
end
# Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
#
# -> { it + it }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11483
class Prism::ItParametersNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [ItParametersNode] a new instance of ItParametersNode
#
# source://prism//lib/prism/node.rb#11485
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11558
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11491
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11496
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11506
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11501
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> ItParametersNode
#
# source://prism//lib/prism/node.rb#11511
sig { params(location: Prism::Location).returns(Prism::ItParametersNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11496
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#11519
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11524
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11542
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11552
def type; end
end
end
# Represents a hash literal without opening and closing braces.
#
# foo(a: b)
# ^^^^
#
# source://prism//lib/prism/node.rb#11567
class Prism::KeywordHashNode < ::Prism::Node
# def initialize: (Integer flags, Array[AssocNode | AssocSplatNode] elements, Location location) -> void
#
# @return [KeywordHashNode] a new instance of KeywordHashNode
#
# source://prism//lib/prism/node.rb#11569
sig do
params(
source: Prism::Source,
flags: Integer,
elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
location: Prism::Location
).void
end
def initialize(source, flags, elements, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11656
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11577
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11582
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11592
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11587
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode], ?location: Location) -> KeywordHashNode
#
# source://prism//lib/prism/node.rb#11597
sig do
params(
flags: Integer,
elements: T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)],
location: Prism::Location
).returns(Prism::KeywordHashNode)
end
def copy(flags: T.unsafe(nil), elements: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11582
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[AssocNode | AssocSplatNode], location: Location }
#
# source://prism//lib/prism/node.rb#11605
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader elements: Array[AssocNode | AssocSplatNode]
#
# source://prism//lib/prism/node.rb#11614
sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) }
def elements; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11622
sig { override.returns(String) }
def inspect; end
# def symbol_keys?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#11617
sig { returns(T::Boolean) }
def symbol_keys?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11640
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#11610
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11650
def type; end
end
end
# Flags for keyword hash nodes.
#
# source://prism//lib/prism/node.rb#19190
module Prism::KeywordHashNodeFlags; end
# a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
#
# source://prism//lib/prism/node.rb#19192
Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer)
# Represents a keyword rest parameter to a method, block, or lambda definition.
#
# def a(**b)
# ^^^
# end
#
# source://prism//lib/prism/node.rb#11669
class Prism::KeywordRestParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
#
# @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode
#
# source://prism//lib/prism/node.rb#11671
sig do
params(
source: Prism::Source,
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11785
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11681
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11686
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11696
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11691
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> KeywordRestParameterNode
#
# source://prism//lib/prism/node.rb#11701
sig do
params(
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::KeywordRestParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11686
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#11709
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11751
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol?
#
# source://prism//lib/prism/node.rb#11718
sig { returns(T.nilable(Symbol)) }
def name; end
# attr_reader name_loc: Location?
#
# source://prism//lib/prism/node.rb#11721
sig { returns(T.nilable(Prism::Location)) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#11746
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#11734
sig { returns(Prism::Location) }
def operator_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#11741
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11769
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#11714
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11779
def type; end
end
end
# Represents using a lambda literal (not the lambda method call).
#
# ->(value) { value * 2 }
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11798
class Prism::LambdaNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, Prism::node? parameters, Prism::node? body, Location location) -> void
#
# @return [LambdaNode] a new instance of LambdaNode
#
# source://prism//lib/prism/node.rb#11800
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
operator_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
parameters: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
location: Prism::Location
).void
end
def initialize(source, locals, operator_loc, opening_loc, closing_loc, parameters, body, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#11927
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11812
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#11875
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11817
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#11888
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#11865
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11830
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11822
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: Prism::node?, ?body: Prism::node?, ?location: Location) -> LambdaNode
#
# source://prism//lib/prism/node.rb#11835
sig do
params(
locals: T::Array[Symbol],
operator_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
parameters: T.nilable(Prism::Node),
body: T.nilable(Prism::Node),
location: Prism::Location
).returns(Prism::LambdaNode)
end
def copy(locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11817
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Prism::node?, body: Prism::node?, location: Location }
#
# source://prism//lib/prism/node.rb#11843
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#11893
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#11848
sig { returns(T::Array[Symbol]) }
def locals; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#11883
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#11858
sig { returns(Prism::Location) }
def opening_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#11878
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#11851
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader parameters: Prism::node?
#
# source://prism//lib/prism/node.rb#11872
sig { returns(T.nilable(Prism::Node)) }
def parameters; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11911
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#11921
def type; end
end
end
# This class is responsible for lexing the source using prism and then
# converting those tokens to be compatible with Ripper. In the vast majority
# of cases, this is a one-to-one mapping of the token type. Everything else
# generally lines up. However, there are a few cases that require special
# handling.
#
# source://prism//lib/prism/lex_compat.rb#12
class Prism::LexCompat
# @return [LexCompat] a new instance of LexCompat
#
# source://prism//lib/prism/lex_compat.rb#619
def initialize(source, **options); end
# Returns the value of attribute options.
#
# source://prism//lib/prism/lex_compat.rb#617
def options; end
# source://prism//lib/prism/lex_compat.rb#624
def result; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/lex_compat.rb#617
def source; end
end
# Ripper doesn't include the rest of the token in the event, so we need to
# trim it down to just the content on the first line when comparing.
#
# source://prism//lib/prism/lex_compat.rb#230
class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token
# source://prism//lib/prism/lex_compat.rb#231
def ==(other); end
end
# A heredoc in this case is a list of tokens that belong to the body of the
# heredoc that should be appended onto the list of tokens when the heredoc
# closes.
#
# source://prism//lib/prism/lex_compat.rb#291
module Prism::LexCompat::Heredoc
class << self
# Here we will split between the two types of heredocs and return the
# object that will store their tokens.
#
# source://prism//lib/prism/lex_compat.rb#603
def build(opening); end
end
end
# Dash heredocs are a little more complicated. They are a list of tokens
# that need to be split on "\\\n" to mimic Ripper's behavior. We also need
# to keep track of the state that the heredoc was opened in.
#
# source://prism//lib/prism/lex_compat.rb#315
class Prism::LexCompat::Heredoc::DashHeredoc
# @return [DashHeredoc] a new instance of DashHeredoc
#
# source://prism//lib/prism/lex_compat.rb#318
def initialize(split); end
# source://prism//lib/prism/lex_compat.rb#323
def <<(token); end
# source://prism//lib/prism/lex_compat.rb#316
def split; end
# source://prism//lib/prism/lex_compat.rb#327
def to_a; end
# source://prism//lib/prism/lex_compat.rb#316
def tokens; end
end
# Heredocs that are dedenting heredocs are a little more complicated.
# Ripper outputs on_ignored_sp tokens for the whitespace that is being
# removed from the output. prism only modifies the node itself and keeps
# the token the same. This simplifies prism, but makes comparing against
# Ripper much harder because there is a length mismatch.
#
# Fortunately, we already have to pull out the heredoc tokens in order to
# insert them into the stream in the correct order. As such, we can do
# some extra manipulation on the tokens to make them match Ripper's
# output by mirroring the dedent logic that Ripper uses.
#
# source://prism//lib/prism/lex_compat.rb#374
class Prism::LexCompat::Heredoc::DedentingHeredoc
# @return [DedentingHeredoc] a new instance of DedentingHeredoc
#
# source://prism//lib/prism/lex_compat.rb#379
def initialize; end
# As tokens are coming in, we track the minimum amount of common leading
# whitespace on plain string content tokens. This allows us to later
# remove that amount of whitespace from the beginning of each line.
#
# source://prism//lib/prism/lex_compat.rb#390
def <<(token); end
# Returns the value of attribute dedent.
#
# source://prism//lib/prism/lex_compat.rb#377
def dedent; end
# Returns the value of attribute dedent_next.
#
# source://prism//lib/prism/lex_compat.rb#377
def dedent_next; end
# Returns the value of attribute embexpr_balance.
#
# source://prism//lib/prism/lex_compat.rb#377
def embexpr_balance; end
# source://prism//lib/prism/lex_compat.rb#427
def to_a; end
# Returns the value of attribute tokens.
#
# source://prism//lib/prism/lex_compat.rb#377
def tokens; end
end
# source://prism//lib/prism/lex_compat.rb#375
Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
# Heredocs that are no dash or tilde heredocs are just a list of tokens.
# We need to keep them around so that we can insert them in the correct
# order back into the token stream and set the state of the last token to
# the state that the heredoc was opened in.
#
# source://prism//lib/prism/lex_compat.rb#296
class Prism::LexCompat::Heredoc::PlainHeredoc
# @return [PlainHeredoc] a new instance of PlainHeredoc
#
# source://prism//lib/prism/lex_compat.rb#299
def initialize; end
# source://prism//lib/prism/lex_compat.rb#303
def <<(token); end
# source://prism//lib/prism/lex_compat.rb#307
def to_a; end
# source://prism//lib/prism/lex_compat.rb#297
def tokens; end
end
# Ident tokens for the most part are exactly the same, except sometimes we
# know an ident is a local when ripper doesn't (when they are introduced
# through named captures in regular expressions). In that case we don't
# compare the state.
#
# source://prism//lib/prism/lex_compat.rb#248
class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token
# source://prism//lib/prism/lex_compat.rb#249
def ==(other); end
end
# Tokens where state should be ignored
# used for :on_comment, :on_heredoc_end, :on_embexpr_end
#
# source://prism//lib/prism/lex_compat.rb#238
class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token
# source://prism//lib/prism/lex_compat.rb#239
def ==(other); end
end
# Ignored newlines can occasionally have a LABEL state attached to them, so
# we compare the state differently here.
#
# source://prism//lib/prism/lex_compat.rb#259
class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token
# source://prism//lib/prism/lex_compat.rb#260
def ==(other); end
end
# If we have an identifier that follows a method name like:
#
# def foo bar
#
# then Ripper will mark bar as END|LABEL if there is a local in a parent
# scope named bar because it hasn't pushed the local table yet. We do this
# more accurately, so we need to allow comparing against both END and
# END|LABEL.
#
# source://prism//lib/prism/lex_compat.rb#279
class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token
# source://prism//lib/prism/lex_compat.rb#280
def ==(other); end
end
# This is a mapping of prism token types to Ripper token types. This is a
# many-to-one mapping because we split up our token types, whereas Ripper
# tends to group them.
#
# source://prism//lib/prism/lex_compat.rb#33
Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash)
# A result class specialized for holding tokens produced by the lexer.
#
# source://prism//lib/prism/lex_compat.rb#14
class Prism::LexCompat::Result < ::Prism::Result
# Create a new lex compat result object with the given values.
#
# @return [Result] a new instance of Result
#
# source://prism//lib/prism/lex_compat.rb#19
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
# Implement the hash pattern matching interface for Result.
#
# source://prism//lib/prism/lex_compat.rb#25
def deconstruct_keys(keys); end
# The list of tokens that were produced by the lexer.
#
# source://prism//lib/prism/lex_compat.rb#16
def value; end
end
# When we produce tokens, we produce the same arrays that Ripper does.
# However, we add a couple of convenience methods onto them to make them a
# little easier to work with. We delegate all other methods to the array.
#
# source://prism//lib/prism/lex_compat.rb#204
class Prism::LexCompat::Token < ::SimpleDelegator
# The type of the token.
#
# source://prism//lib/prism/lex_compat.rb#213
def event; end
# The location of the token in the source.
#
# source://prism//lib/prism/lex_compat.rb#208
def location; end
# The state of the lexer when this token was produced.
#
# source://prism//lib/prism/lex_compat.rb#223
def state; end
# The slice of the source that this token represents.
#
# source://prism//lib/prism/lex_compat.rb#218
def value; end
end
# This is a result specific to the `lex` and `lex_file` methods.
#
# source://prism//lib/prism/parse_result.rb#610
class Prism::LexResult < ::Prism::Result
# Create a new lex result object with the given values.
#
# @return [LexResult] a new instance of LexResult
#
# source://prism//lib/prism/parse_result.rb#615
sig do
params(
value: T::Array[T.untyped],
comments: T::Array[Prism::Comment],
magic_comments: T::Array[Prism::MagicComment],
data_loc: T.nilable(Prism::Location),
errors: T::Array[Prism::ParseError],
warnings: T::Array[Prism::ParseWarning],
source: Prism::Source
).void
end
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
# Implement the hash pattern matching interface for LexResult.
#
# source://prism//lib/prism/parse_result.rb#621
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The list of tokens that were parsed from the source code.
#
# source://prism//lib/prism/parse_result.rb#612
sig { returns(T::Array[T.untyped]) }
def value; end
end
# This is a class that wraps the Ripper lexer to produce almost exactly the
# same tokens.
#
# source://prism//lib/prism/lex_compat.rb#872
class Prism::LexRipper
# @return [LexRipper] a new instance of LexRipper
#
# source://prism//lib/prism/lex_compat.rb#875
def initialize(source); end
# source://prism//lib/prism/lex_compat.rb#879
def result; end
# source://prism//lib/prism/lex_compat.rb#873
def source; end
private
# source://prism//lib/prism/lex_compat.rb#913
def lex(source); end
end
# Represents the use of the `&&=` operator for assignment to a local variable.
#
# target &&= value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#11943
class Prism::LocalVariableAndWriteNode < ::Prism::Node
# def initialize: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
#
# @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#11945
sig do
params(
source: Prism::Source,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
depth: Integer,
location: Prism::Location
).void
end
def initialize(source, name_loc, operator_loc, value, name, depth, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12051
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#11956
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11961
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#11971
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#11966
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableAndWriteNode
#
# source://prism//lib/prism/node.rb#11976
sig do
params(
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
depth: Integer,
location: Prism::Location
).returns(Prism::LocalVariableAndWriteNode)
end
def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#11961
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#11984
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader depth: Integer
#
# source://prism//lib/prism/node.rb#12009
sig { returns(Integer) }
def depth; end
# source://prism//lib/prism/desugar_compiler.rb#199
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12017
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#12006
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#11989
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#12012
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#11996
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12035
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#12003
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12045
def type; end
end
end
# Represents assigning to a local variable using an operator that isn't `=`.
#
# target += value
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#12065
class Prism::LocalVariableOperatorWriteNode < ::Prism::Node
# def initialize: (Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth, Location location) -> void
#
# @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#12067
sig do
params(
source: Prism::Source,
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
binary_operator: Symbol,
depth: Integer,
location: Prism::Location
).void
end
def initialize(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12172
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12079
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader binary_operator: Symbol
#
# source://prism//lib/prism/node.rb#12132
sig { returns(Symbol) }
def binary_operator; end
# attr_reader binary_operator_loc: Location
#
# source://prism//lib/prism/node.rb#12119
sig { returns(Prism::Location) }
def binary_operator_loc; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12084
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12094
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12089
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
#
# source://prism//lib/prism/node.rb#12099
sig do
params(
name_loc: Prism::Location,
binary_operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
binary_operator: Symbol,
depth: Integer,
location: Prism::Location
).returns(Prism::LocalVariableOperatorWriteNode)
end
def copy(name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12084
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#12107
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader depth: Integer
#
# source://prism//lib/prism/node.rb#12135
sig { returns(Integer) }
def depth; end
# source://prism//lib/prism/desugar_compiler.rb#211
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12138
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#12129
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#12112
sig { returns(Prism::Location) }
def name_loc; end
# Returns the binary operator used to modify the receiver. This method is
# deprecated in favor of #binary_operator.
#
# source://prism//lib/prism/node_ext.rb#435
def operator; end
# Returns the location of the binary operator used to modify the receiver.
# This method is deprecated in favor of #binary_operator_loc.
#
# source://prism//lib/prism/node_ext.rb#442
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12156
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#12126
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12166
def type; end
end
end
# Represents the use of the `||=` operator for assignment to a local variable.
#
# target ||= value
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#12187
class Prism::LocalVariableOrWriteNode < ::Prism::Node
# def initialize: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
#
# @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#12189
sig do
params(
source: Prism::Source,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
depth: Integer,
location: Prism::Location
).void
end
def initialize(source, name_loc, operator_loc, value, name, depth, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12295
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12200
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12205
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12215
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12210
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOrWriteNode
#
# source://prism//lib/prism/node.rb#12220
sig do
params(
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
name: Symbol,
depth: Integer,
location: Prism::Location
).returns(Prism::LocalVariableOrWriteNode)
end
def copy(name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12205
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#12228
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader depth: Integer
#
# source://prism//lib/prism/node.rb#12253
sig { returns(Integer) }
def depth; end
# source://prism//lib/prism/desugar_compiler.rb#205
def desugar; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12261
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#12250
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#12233
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#12256
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#12240
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12279
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#12247
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12289
def type; end
end
end
# Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
#
# foo
# ^^^
#
# source://prism//lib/prism/node.rb#12309
class Prism::LocalVariableReadNode < ::Prism::Node
# def initialize: (Symbol name, Integer depth, Location location) -> void
#
# @return [LocalVariableReadNode] a new instance of LocalVariableReadNode
#
# source://prism//lib/prism/node.rb#12311
sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void }
def initialize(source, name, depth, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12406
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12319
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12324
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12334
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12329
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableReadNode
#
# source://prism//lib/prism/node.rb#12339
sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableReadNode) }
def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12324
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#12347
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The number of visible scopes that should be searched to find the origin of this local variable.
#
# foo = 1; foo # depth 0
#
# bar = 2; tap { bar } # depth 1
#
# The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
#
# source://prism//lib/prism/node.rb#12369
sig { returns(Integer) }
def depth; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12372
sig { override.returns(String) }
def inspect; end
# The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# x # name `:x`
#
# _Test # name `:_Test`
#
# Note that this can also be an underscore followed by a number for the default block parameters.
#
# _1 # name `:_1`
#
# source://prism//lib/prism/node.rb#12360
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12390
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12400
def type; end
end
end
# Represents writing to a local variable in a context that doesn't have an explicit value.
#
# foo, bar = baz
# ^^^ ^^^
#
# source://prism//lib/prism/node.rb#12417
class Prism::LocalVariableTargetNode < ::Prism::Node
# def initialize: (Symbol name, Integer depth, Location location) -> void
#
# @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode
#
# source://prism//lib/prism/node.rb#12419
sig { params(source: Prism::Source, name: Symbol, depth: Integer, location: Prism::Location).void }
def initialize(source, name, depth, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12500
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12427
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12432
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12442
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12437
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableTargetNode
#
# source://prism//lib/prism/node.rb#12447
sig { params(name: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableTargetNode) }
def copy(name: T.unsafe(nil), depth: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12432
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#12455
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader depth: Integer
#
# source://prism//lib/prism/node.rb#12463
sig { returns(Integer) }
def depth; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12466
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#12460
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12484
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12494
def type; end
end
end
# Represents writing to a local variable.
#
# foo = 1
# ^^^^^^^
#
# source://prism//lib/prism/node.rb#12511
class Prism::LocalVariableWriteNode < ::Prism::Node
# def initialize: (Symbol name, Integer depth, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
#
# @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode
#
# source://prism//lib/prism/node.rb#12513
sig do
params(
source: Prism::Source,
name: Symbol,
depth: Integer,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, name, depth, name_loc, value, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12645
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12524
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12529
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12539
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12534
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> LocalVariableWriteNode
#
# source://prism//lib/prism/node.rb#12544
sig do
params(
name: Symbol,
depth: Integer,
name_loc: Prism::Location,
value: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::LocalVariableWriteNode)
end
def copy(name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12529
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#12552
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The number of semantic scopes we have to traverse to find the declaration of this variable.
#
# foo = 1 # depth 0
#
# tap { foo = 1 } # depth 1
#
# The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
#
# source://prism//lib/prism/node.rb#12570
sig { returns(Integer) }
def depth; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12611
sig { override.returns(String) }
def inspect; end
# The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
#
# foo = :bar # name `:foo`
#
# abc = 123 # name `:abc`
#
# source://prism//lib/prism/node.rb#12561
sig { returns(Symbol) }
def name; end
# The location of the variable name.
#
# foo = :bar
# ^^^
#
# source://prism//lib/prism/node.rb#12576
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#12606
sig { returns(String) }
def operator; end
# The location of the `=` operator.
#
# x = :y
# ^
#
# source://prism//lib/prism/node.rb#12599
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12629
sig { override.returns(Symbol) }
def type; end
# The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# foo = :bar
# ^^^^
#
# abc = 1234
# ^^^^
#
# Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
#
# foo = foo
#
# source://prism//lib/prism/node.rb#12593
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12639
def type; end
end
end
# This represents a location in the source.
#
# source://prism//lib/prism/parse_result.rb#156
class Prism::Location
# Create a new location object with the given source, start byte offset, and
# byte length.
#
# @return [Location] a new instance of Location
#
# source://prism//lib/prism/parse_result.rb#171
sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void }
def initialize(source, start_offset, length); end
# Returns true if the given other location is equal to this location.
#
# source://prism//lib/prism/parse_result.rb#335
sig { params(other: T.untyped).returns(T::Boolean) }
def ==(other); end
# Join this location with the first occurrence of the string in the source
# that occurs after this location on the same line, and return the new
# location. This will raise an error if the string does not exist.
#
# source://prism//lib/prism/parse_result.rb#354
sig { params(string: String).returns(Prism::Location) }
def adjoin(string); end
# Returns a new location that is the result of chopping off the last byte.
#
# source://prism//lib/prism/parse_result.rb#217
sig { returns(Prism::Location) }
def chop; end
# Returns all comments that are associated with this location (both leading
# and trailing comments).
#
# source://prism//lib/prism/parse_result.rb#207
sig { returns(T::Array[Prism::Comment]) }
def comments; end
# Create a new location object with the given options.
#
# source://prism//lib/prism/parse_result.rb#212
sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) }
def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end
# Implement the hash pattern matching interface for Location.
#
# source://prism//lib/prism/parse_result.rb#325
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The column number in characters where this location ends from the start of
# the line.
#
# source://prism//lib/prism/parse_result.rb#314
sig { returns(Integer) }
def end_character_column; end
# The character offset from the beginning of the source where this location
# ends.
#
# source://prism//lib/prism/parse_result.rb#263
sig { returns(Integer) }
def end_character_offset; end
# The column number in code units of the given encoding where this location
# ends from the start of the line.
#
# source://prism//lib/prism/parse_result.rb#320
sig { params(encoding: Encoding).returns(Integer) }
def end_code_units_column(encoding = T.unsafe(nil)); end
# The offset from the start of the file in code units of the given encoding.
#
# source://prism//lib/prism/parse_result.rb#268
sig { params(encoding: Encoding).returns(Integer) }
def end_code_units_offset(encoding = T.unsafe(nil)); end
# The column number in bytes where this location ends from the start of the
# line.
#
# source://prism//lib/prism/parse_result.rb#308
sig { returns(Integer) }
def end_column; end
# The line number where this location ends.
#
# source://prism//lib/prism/parse_result.rb#284
sig { returns(Integer) }
def end_line; end
# The byte offset from the beginning of the source where this location ends.
#
# source://prism//lib/prism/parse_result.rb#257
sig { returns(Integer) }
def end_offset; end
# Returns a string representation of this location.
#
# source://prism//lib/prism/parse_result.rb#222
sig { returns(String) }
def inspect; end
# Returns a new location that stretches from this location to the given
# other location. Raises an error if this location is not before the other
# location or if they don't share the same source.
#
# source://prism//lib/prism/parse_result.rb#344
sig { params(other: Prism::Location).returns(Prism::Location) }
def join(other); end
# Attach a comment to the leading comments of this location.
#
# source://prism//lib/prism/parse_result.rb#190
sig { params(comment: Prism::Comment).void }
def leading_comment(comment); end
# These are the comments that are associated with this location that exist
# before the start of this location.
#
# source://prism//lib/prism/parse_result.rb#185
sig { returns(T::Array[Prism::Comment]) }
def leading_comments; end
# The length of this location in bytes.
#
# source://prism//lib/prism/parse_result.rb#167
sig { returns(Integer) }
def length; end
# Implement the pretty print interface for Location.
#
# source://prism//lib/prism/parse_result.rb#330
sig { params(q: T.untyped).void }
def pretty_print(q); end
# The source code that this location represents.
#
# source://prism//lib/prism/parse_result.rb#232
sig { returns(String) }
def slice; end
# The source code that this location represents starting from the beginning
# of the line that this location starts on to the end of the line that this
# location ends on.
#
# source://prism//lib/prism/parse_result.rb#239
def slice_lines; end
# Returns all of the lines of the source code associated with this location.
#
# source://prism//lib/prism/parse_result.rb#227
sig { returns(T::Array[String]) }
def source_lines; end
# The column number in characters where this location ends from the start of
# the line.
#
# source://prism//lib/prism/parse_result.rb#296
sig { returns(Integer) }
def start_character_column; end
# The character offset from the beginning of the source where this location
# starts.
#
# source://prism//lib/prism/parse_result.rb#247
sig { returns(Integer) }
def start_character_offset; end
# The column number in code units of the given encoding where this location
# starts from the start of the line.
#
# source://prism//lib/prism/parse_result.rb#302
sig { params(encoding: Encoding).returns(Integer) }
def start_code_units_column(encoding = T.unsafe(nil)); end
# The offset from the start of the file in code units of the given encoding.
#
# source://prism//lib/prism/parse_result.rb#252
sig { params(encoding: Encoding).returns(Integer) }
def start_code_units_offset(encoding = T.unsafe(nil)); end
# The column number in bytes where this location starts from the start of
# the line.
#
# source://prism//lib/prism/parse_result.rb#290
sig { returns(Integer) }
def start_column; end
# The line number where this location starts.
#
# source://prism//lib/prism/parse_result.rb#273
sig { returns(Integer) }
def start_line; end
# The content of the line where this location starts before this location.
#
# source://prism//lib/prism/parse_result.rb#278
sig { returns(String) }
def start_line_slice; end
# The byte offset from the beginning of the source where this location
# starts.
#
# source://prism//lib/prism/parse_result.rb#164
sig { returns(Integer) }
def start_offset; end
# Attach a comment to the trailing comments of this location.
#
# source://prism//lib/prism/parse_result.rb#201
sig { params(comment: Prism::Comment).void }
def trailing_comment(comment); end
# These are the comments that are associated with this location that exist
# after the end of this location.
#
# source://prism//lib/prism/parse_result.rb#196
sig { returns(T::Array[Prism::Comment]) }
def trailing_comments; end
protected
# A Source object that is used to determine more information from the given
# offset and length.
#
# source://prism//lib/prism/parse_result.rb#159
sig { returns(Prism::Source) }
def source; end
end
# Flags for while and until loop nodes.
#
# source://prism//lib/prism/node.rb#19196
module Prism::LoopFlags; end
# a loop after a begin statement, so the body is executed first before the condition
#
# source://prism//lib/prism/node.rb#19198
Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer)
# This represents a magic comment that was encountered during parsing.
#
# source://prism//lib/prism/parse_result.rb#416
class Prism::MagicComment
# Create a new magic comment object with the given key and value locations.
#
# @return [MagicComment] a new instance of MagicComment
#
# source://prism//lib/prism/parse_result.rb#424
sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void }
def initialize(key_loc, value_loc); end
# Implement the hash pattern matching interface for MagicComment.
#
# source://prism//lib/prism/parse_result.rb#440
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Returns a string representation of this magic comment.
#
# source://prism//lib/prism/parse_result.rb#445
sig { returns(String) }
def inspect; end
# Returns the key of the magic comment by slicing it from the source code.
#
# source://prism//lib/prism/parse_result.rb#430
sig { returns(String) }
def key; end
# A Location object representing the location of the key in the source.
#
# source://prism//lib/prism/parse_result.rb#418
sig { returns(Prism::Location) }
def key_loc; end
# Returns the value of the magic comment by slicing it from the source code.
#
# source://prism//lib/prism/parse_result.rb#435
sig { returns(String) }
def value; end
# A Location object representing the location of the value in the source.
#
# source://prism//lib/prism/parse_result.rb#421
sig { returns(Prism::Location) }
def value_loc; end
end
# Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
#
# if /foo/i then end
# ^^^^^^
#
# source://prism//lib/prism/node.rb#12659
class Prism::MatchLastLineNode < ::Prism::Node
include ::Prism::RegularExpressionOptions
# def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
#
# @return [MatchLastLineNode] a new instance of MatchLastLineNode
#
# source://prism//lib/prism/node.rb#12661
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12837
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12672
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def ascii_8bit?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12758
sig { returns(T::Boolean) }
def ascii_8bit?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12677
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#12798
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#12723
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12687
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12682
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def content: () -> String
#
# source://prism//lib/prism/node.rb#12793
sig { returns(String) }
def content; end
# attr_reader content_loc: Location
#
# source://prism//lib/prism/node.rb#12716
sig { returns(Prism::Location) }
def content_loc; end
# def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> MatchLastLineNode
#
# source://prism//lib/prism/node.rb#12692
sig do
params(
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).returns(Prism::MatchLastLineNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12677
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
#
# source://prism//lib/prism/node.rb#12700
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def euc_jp?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12753
sig { returns(T::Boolean) }
def euc_jp?; end
# def extended?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12738
sig { returns(T::Boolean) }
def extended?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12778
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_us_ascii_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12783
sig { returns(T::Boolean) }
def forced_us_ascii_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12773
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def ignore_case?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12733
sig { returns(T::Boolean) }
def ignore_case?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12803
sig { override.returns(String) }
def inspect; end
# def multi_line?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12743
sig { returns(T::Boolean) }
def multi_line?; end
# def once?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12748
sig { returns(T::Boolean) }
def once?; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#12788
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#12709
sig { returns(Prism::Location) }
def opening_loc; end
sig { returns(Integer) }
def options; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12821
sig { override.returns(Symbol) }
def type; end
# attr_reader unescaped: String
#
# source://prism//lib/prism/node.rb#12730
sig { returns(String) }
def unescaped; end
# def utf_8?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12768
sig { returns(T::Boolean) }
def utf_8?; end
# def windows_31j?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#12763
sig { returns(T::Boolean) }
def windows_31j?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#12705
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12831
def type; end
end
end
# Represents the use of the modifier `in` operator.
#
# foo in bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#12851
class Prism::MatchPredicateNode < ::Prism::Node
# def initialize: (Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
#
# @return [MatchPredicateNode] a new instance of MatchPredicateNode
#
# source://prism//lib/prism/node.rb#12853
sig do
params(
source: Prism::Source,
value: Prism::Node,
pattern: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, value, pattern, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#12947
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12862
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12867
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12877
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12872
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchPredicateNode
#
# source://prism//lib/prism/node.rb#12882
sig do
params(
value: Prism::Node,
pattern: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::MatchPredicateNode)
end
def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12867
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#12890
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#12913
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#12908
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#12901
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader pattern: Prism::node
#
# source://prism//lib/prism/node.rb#12898
sig { returns(Prism::Node) }
def pattern; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12931
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#12895
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#12941
def type; end
end
end
# Represents the use of the `=>` operator.
#
# foo => bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#12959
class Prism::MatchRequiredNode < ::Prism::Node
# def initialize: (Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
#
# @return [MatchRequiredNode] a new instance of MatchRequiredNode
#
# source://prism//lib/prism/node.rb#12961
sig do
params(
source: Prism::Source,
value: Prism::Node,
pattern: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, value, pattern, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13055
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#12970
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12975
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#12985
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#12980
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchRequiredNode
#
# source://prism//lib/prism/node.rb#12990
sig do
params(
value: Prism::Node,
pattern: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::MatchRequiredNode)
end
def copy(value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#12975
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#12998
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13021
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#13016
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#13009
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader pattern: Prism::node
#
# source://prism//lib/prism/node.rb#13006
sig { returns(Prism::Node) }
def pattern; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13039
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#13003
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13049
def type; end
end
end
# Represents writing local variables using a regular expression match with named capture groups.
#
# /(?<foo>bar)/ =~ baz
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#13067
class Prism::MatchWriteNode < ::Prism::Node
# def initialize: (CallNode call, Array[LocalVariableTargetNode] targets, Location location) -> void
#
# @return [MatchWriteNode] a new instance of MatchWriteNode
#
# source://prism//lib/prism/node.rb#13069
sig do
params(
source: Prism::Source,
call: Prism::CallNode,
targets: T::Array[Prism::LocalVariableTargetNode],
location: Prism::Location
).void
end
def initialize(source, call, targets, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13150
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13077
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader call: CallNode
#
# source://prism//lib/prism/node.rb#13110
sig { returns(Prism::CallNode) }
def call; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13082
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13092
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13087
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?call: CallNode, ?targets: Array[LocalVariableTargetNode], ?location: Location) -> MatchWriteNode
#
# source://prism//lib/prism/node.rb#13097
sig do
params(
call: Prism::CallNode,
targets: T::Array[Prism::LocalVariableTargetNode],
location: Prism::Location
).returns(Prism::MatchWriteNode)
end
def copy(call: T.unsafe(nil), targets: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13082
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { call: CallNode, targets: Array[LocalVariableTargetNode], location: Location }
#
# source://prism//lib/prism/node.rb#13105
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13116
sig { override.returns(String) }
def inspect; end
# attr_reader targets: Array[LocalVariableTargetNode]
#
# source://prism//lib/prism/node.rb#13113
sig { returns(T::Array[Prism::LocalVariableTargetNode]) }
def targets; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13134
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13144
def type; end
end
end
# Represents a node that is missing from the source and results in a syntax error.
#
# source://prism//lib/prism/node.rb#13159
class Prism::MissingNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [MissingNode] a new instance of MissingNode
#
# source://prism//lib/prism/node.rb#13161
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13234
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13167
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13172
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13182
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13177
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> MissingNode
#
# source://prism//lib/prism/node.rb#13187
sig { params(location: Prism::Location).returns(Prism::MissingNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13172
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#13195
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13200
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13218
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13228
def type; end
end
end
# Represents a module declaration involving the `module` keyword.
#
# module Foo end
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#13243
class Prism::ModuleNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, Location module_keyword_loc, Prism::node constant_path, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
#
# @return [ModuleNode] a new instance of ModuleNode
#
# source://prism//lib/prism/node.rb#13245
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
module_keyword_loc: Prism::Location,
constant_path: Prism::Node,
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
name: Symbol,
location: Prism::Location
).void
end
def initialize(source, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13363
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13257
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#13306
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13262
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13275
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13267
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader constant_path: Prism::node
#
# source://prism//lib/prism/node.rb#13303
sig { returns(Prism::Node) }
def constant_path; end
# def copy: (?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ModuleNode
#
# source://prism//lib/prism/node.rb#13280
sig do
params(
locals: T::Array[Symbol],
module_keyword_loc: Prism::Location,
constant_path: Prism::Node,
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
name: Symbol,
location: Prism::Location
).returns(Prism::ModuleNode)
end
def copy(locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13262
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], module_keyword_loc: Location, constant_path: Prism::node, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#13288
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#13324
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#13309
sig { returns(Prism::Location) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13329
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#13293
sig { returns(T::Array[Symbol]) }
def locals; end
# def module_keyword: () -> String
#
# source://prism//lib/prism/node.rb#13319
sig { returns(String) }
def module_keyword; end
# attr_reader module_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#13296
sig { returns(Prism::Location) }
def module_keyword_loc; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#13316
sig { returns(Symbol) }
def name; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13347
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13357
def type; end
end
end
# Represents a multi-target expression.
#
# a, (b, c) = 1, 2, 3
# ^^^^^^
#
# source://prism//lib/prism/node.rb#13379
class Prism::MultiTargetNode < ::Prism::Node
# def initialize: (Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc, Location location) -> void
#
# @return [MultiTargetNode] a new instance of MultiTargetNode
#
# source://prism//lib/prism/node.rb#13381
sig do
params(
source: Prism::Source,
lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
rest: T.nilable(Prism::Node),
rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)],
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13508
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13392
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13397
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13411
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13402
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?location: Location) -> MultiTargetNode
#
# source://prism//lib/prism/node.rb#13416
sig do
params(
lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)],
rest: T.nilable(Prism::Node),
rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)],
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::MultiTargetNode)
end
def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13397
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#13424
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13474
sig { override.returns(String) }
def inspect; end
# attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode]
#
# source://prism//lib/prism/node.rb#13429
sig do
returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)])
end
def lefts; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#13464
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#13438
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# attr_reader rest: Prism::node?
#
# source://prism//lib/prism/node.rb#13432
sig { returns(T.nilable(Prism::Node)) }
def rest; end
# attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode]
#
# source://prism//lib/prism/node.rb#13435
sig do
returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode)])
end
def rights; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#13469
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#13451
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13492
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13502
def type; end
end
end
# Represents a write to a multi-target expression.
#
# a, b, c = 1, 2, 3
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#13524
class Prism::MultiWriteNode < ::Prism::Node
# def initialize: (Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [MultiWriteNode] a new instance of MultiWriteNode
#
# source://prism//lib/prism/node.rb#13526
sig do
params(
source: Prism::Source,
lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
rest: T.nilable(Prism::Node),
rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13671
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13539
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13544
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13559
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13549
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> MultiWriteNode
#
# source://prism//lib/prism/node.rb#13564
sig do
params(
lefts: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
rest: T.nilable(Prism::Node),
rights: T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)],
lparen_loc: T.nilable(Prism::Location),
rparen_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::MultiWriteNode)
end
def copy(lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13544
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#13572
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13637
sig { override.returns(String) }
def inspect; end
# attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
#
# source://prism//lib/prism/node.rb#13577
sig do
returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)])
end
def lefts; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#13622
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#13586
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#13632
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#13612
sig { returns(Prism::Location) }
def operator_loc; end
# attr_reader rest: Prism::node?
#
# source://prism//lib/prism/node.rb#13580
sig { returns(T.nilable(Prism::Node)) }
def rest; end
# attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
#
# source://prism//lib/prism/node.rb#13583
sig do
returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode)])
end
def rights; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#13627
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#13599
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13655
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#13619
sig { returns(Prism::Node) }
def value; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13665
def type; end
end
end
# This visitor walks through the tree and copies each node as it is being
# visited. This is useful for consumers that want to mutate the tree, as you
# can change subtrees in place without effecting the rest of the tree.
#
# source://prism//lib/prism/mutation_compiler.rb#13
class Prism::MutationCompiler < ::Prism::Compiler
# Copy a AliasGlobalVariableNode node
#
# source://prism//lib/prism/mutation_compiler.rb#15
def visit_alias_global_variable_node(node); end
# Copy a AliasMethodNode node
#
# source://prism//lib/prism/mutation_compiler.rb#20
def visit_alias_method_node(node); end
# Copy a AlternationPatternNode node
#
# source://prism//lib/prism/mutation_compiler.rb#25
def visit_alternation_pattern_node(node); end
# Copy a AndNode node
#
# source://prism//lib/prism/mutation_compiler.rb#30
def visit_and_node(node); end
# Copy a ArgumentsNode node
#
# source://prism//lib/prism/mutation_compiler.rb#35
def visit_arguments_node(node); end
# Copy a ArrayNode node
#
# source://prism//lib/prism/mutation_compiler.rb#40
def visit_array_node(node); end
# Copy a ArrayPatternNode node
#
# source://prism//lib/prism/mutation_compiler.rb#45
def visit_array_pattern_node(node); end
# Copy a AssocNode node
#
# source://prism//lib/prism/mutation_compiler.rb#50
def visit_assoc_node(node); end
# Copy a AssocSplatNode node
#
# source://prism//lib/prism/mutation_compiler.rb#55
def visit_assoc_splat_node(node); end
# Copy a BackReferenceReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#60
def visit_back_reference_read_node(node); end
# Copy a BeginNode node
#
# source://prism//lib/prism/mutation_compiler.rb#65
def visit_begin_node(node); end
# Copy a BlockArgumentNode node
#
# source://prism//lib/prism/mutation_compiler.rb#70
def visit_block_argument_node(node); end
# Copy a BlockLocalVariableNode node
#
# source://prism//lib/prism/mutation_compiler.rb#75
def visit_block_local_variable_node(node); end
# Copy a BlockNode node
#
# source://prism//lib/prism/mutation_compiler.rb#80
def visit_block_node(node); end
# Copy a BlockParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#85
def visit_block_parameter_node(node); end
# Copy a BlockParametersNode node
#
# source://prism//lib/prism/mutation_compiler.rb#90
def visit_block_parameters_node(node); end
# Copy a BreakNode node
#
# source://prism//lib/prism/mutation_compiler.rb#95
def visit_break_node(node); end
# Copy a CallAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#100
def visit_call_and_write_node(node); end
# Copy a CallNode node
#
# source://prism//lib/prism/mutation_compiler.rb#105
def visit_call_node(node); end
# Copy a CallOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#110
def visit_call_operator_write_node(node); end
# Copy a CallOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#115
def visit_call_or_write_node(node); end
# Copy a CallTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#120
def visit_call_target_node(node); end
# Copy a CapturePatternNode node
#
# source://prism//lib/prism/mutation_compiler.rb#125
def visit_capture_pattern_node(node); end
# Copy a CaseMatchNode node
#
# source://prism//lib/prism/mutation_compiler.rb#130
def visit_case_match_node(node); end
# Copy a CaseNode node
#
# source://prism//lib/prism/mutation_compiler.rb#135
def visit_case_node(node); end
# Copy a ClassNode node
#
# source://prism//lib/prism/mutation_compiler.rb#140
def visit_class_node(node); end
# Copy a ClassVariableAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#145
def visit_class_variable_and_write_node(node); end
# Copy a ClassVariableOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#150
def visit_class_variable_operator_write_node(node); end
# Copy a ClassVariableOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#155
def visit_class_variable_or_write_node(node); end
# Copy a ClassVariableReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#160
def visit_class_variable_read_node(node); end
# Copy a ClassVariableTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#165
def visit_class_variable_target_node(node); end
# Copy a ClassVariableWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#170
def visit_class_variable_write_node(node); end
# Copy a ConstantAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#175
def visit_constant_and_write_node(node); end
# Copy a ConstantOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#180
def visit_constant_operator_write_node(node); end
# Copy a ConstantOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#185
def visit_constant_or_write_node(node); end
# Copy a ConstantPathAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#190
def visit_constant_path_and_write_node(node); end
# Copy a ConstantPathNode node
#
# source://prism//lib/prism/mutation_compiler.rb#195
def visit_constant_path_node(node); end
# Copy a ConstantPathOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#200
def visit_constant_path_operator_write_node(node); end
# Copy a ConstantPathOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#205
def visit_constant_path_or_write_node(node); end
# Copy a ConstantPathTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#210
def visit_constant_path_target_node(node); end
# Copy a ConstantPathWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#215
def visit_constant_path_write_node(node); end
# Copy a ConstantReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#220
def visit_constant_read_node(node); end
# Copy a ConstantTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#225
def visit_constant_target_node(node); end
# Copy a ConstantWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#230
def visit_constant_write_node(node); end
# Copy a DefNode node
#
# source://prism//lib/prism/mutation_compiler.rb#235
def visit_def_node(node); end
# Copy a DefinedNode node
#
# source://prism//lib/prism/mutation_compiler.rb#240
def visit_defined_node(node); end
# Copy a ElseNode node
#
# source://prism//lib/prism/mutation_compiler.rb#245
def visit_else_node(node); end
# Copy a EmbeddedStatementsNode node
#
# source://prism//lib/prism/mutation_compiler.rb#250
def visit_embedded_statements_node(node); end
# Copy a EmbeddedVariableNode node
#
# source://prism//lib/prism/mutation_compiler.rb#255
def visit_embedded_variable_node(node); end
# Copy a EnsureNode node
#
# source://prism//lib/prism/mutation_compiler.rb#260
def visit_ensure_node(node); end
# Copy a FalseNode node
#
# source://prism//lib/prism/mutation_compiler.rb#265
def visit_false_node(node); end
# Copy a FindPatternNode node
#
# source://prism//lib/prism/mutation_compiler.rb#270
def visit_find_pattern_node(node); end
# Copy a FlipFlopNode node
#
# source://prism//lib/prism/mutation_compiler.rb#275
def visit_flip_flop_node(node); end
# Copy a FloatNode node
#
# source://prism//lib/prism/mutation_compiler.rb#280
def visit_float_node(node); end
# Copy a ForNode node
#
# source://prism//lib/prism/mutation_compiler.rb#285
def visit_for_node(node); end
# Copy a ForwardingArgumentsNode node
#
# source://prism//lib/prism/mutation_compiler.rb#290
def visit_forwarding_arguments_node(node); end
# Copy a ForwardingParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#295
def visit_forwarding_parameter_node(node); end
# Copy a ForwardingSuperNode node
#
# source://prism//lib/prism/mutation_compiler.rb#300
def visit_forwarding_super_node(node); end
# Copy a GlobalVariableAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#305
def visit_global_variable_and_write_node(node); end
# Copy a GlobalVariableOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#310
def visit_global_variable_operator_write_node(node); end
# Copy a GlobalVariableOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#315
def visit_global_variable_or_write_node(node); end
# Copy a GlobalVariableReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#320
def visit_global_variable_read_node(node); end
# Copy a GlobalVariableTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#325
def visit_global_variable_target_node(node); end
# Copy a GlobalVariableWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#330
def visit_global_variable_write_node(node); end
# Copy a HashNode node
#
# source://prism//lib/prism/mutation_compiler.rb#335
def visit_hash_node(node); end
# Copy a HashPatternNode node
#
# source://prism//lib/prism/mutation_compiler.rb#340
def visit_hash_pattern_node(node); end
# Copy a IfNode node
#
# source://prism//lib/prism/mutation_compiler.rb#345
def visit_if_node(node); end
# Copy a ImaginaryNode node
#
# source://prism//lib/prism/mutation_compiler.rb#350
def visit_imaginary_node(node); end
# Copy a ImplicitNode node
#
# source://prism//lib/prism/mutation_compiler.rb#355
def visit_implicit_node(node); end
# Copy a ImplicitRestNode node
#
# source://prism//lib/prism/mutation_compiler.rb#360
def visit_implicit_rest_node(node); end
# Copy a InNode node
#
# source://prism//lib/prism/mutation_compiler.rb#365
def visit_in_node(node); end
# Copy a IndexAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#370
def visit_index_and_write_node(node); end
# Copy a IndexOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#375
def visit_index_operator_write_node(node); end
# Copy a IndexOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#380
def visit_index_or_write_node(node); end
# Copy a IndexTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#385
def visit_index_target_node(node); end
# Copy a InstanceVariableAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#390
def visit_instance_variable_and_write_node(node); end
# Copy a InstanceVariableOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#395
def visit_instance_variable_operator_write_node(node); end
# Copy a InstanceVariableOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#400
def visit_instance_variable_or_write_node(node); end
# Copy a InstanceVariableReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#405
def visit_instance_variable_read_node(node); end
# Copy a InstanceVariableTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#410
def visit_instance_variable_target_node(node); end
# Copy a InstanceVariableWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#415
def visit_instance_variable_write_node(node); end
# Copy a IntegerNode node
#
# source://prism//lib/prism/mutation_compiler.rb#420
def visit_integer_node(node); end
# Copy a InterpolatedMatchLastLineNode node
#
# source://prism//lib/prism/mutation_compiler.rb#425
def visit_interpolated_match_last_line_node(node); end
# Copy a InterpolatedRegularExpressionNode node
#
# source://prism//lib/prism/mutation_compiler.rb#430
def visit_interpolated_regular_expression_node(node); end
# Copy a InterpolatedStringNode node
#
# source://prism//lib/prism/mutation_compiler.rb#435
def visit_interpolated_string_node(node); end
# Copy a InterpolatedSymbolNode node
#
# source://prism//lib/prism/mutation_compiler.rb#440
def visit_interpolated_symbol_node(node); end
# Copy a InterpolatedXStringNode node
#
# source://prism//lib/prism/mutation_compiler.rb#445
def visit_interpolated_x_string_node(node); end
# Copy a ItLocalVariableReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#450
def visit_it_local_variable_read_node(node); end
# Copy a ItParametersNode node
#
# source://prism//lib/prism/mutation_compiler.rb#455
def visit_it_parameters_node(node); end
# Copy a KeywordHashNode node
#
# source://prism//lib/prism/mutation_compiler.rb#460
def visit_keyword_hash_node(node); end
# Copy a KeywordRestParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#465
def visit_keyword_rest_parameter_node(node); end
# Copy a LambdaNode node
#
# source://prism//lib/prism/mutation_compiler.rb#470
def visit_lambda_node(node); end
# Copy a LocalVariableAndWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#475
def visit_local_variable_and_write_node(node); end
# Copy a LocalVariableOperatorWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#480
def visit_local_variable_operator_write_node(node); end
# Copy a LocalVariableOrWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#485
def visit_local_variable_or_write_node(node); end
# Copy a LocalVariableReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#490
def visit_local_variable_read_node(node); end
# Copy a LocalVariableTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#495
def visit_local_variable_target_node(node); end
# Copy a LocalVariableWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#500
def visit_local_variable_write_node(node); end
# Copy a MatchLastLineNode node
#
# source://prism//lib/prism/mutation_compiler.rb#505
def visit_match_last_line_node(node); end
# Copy a MatchPredicateNode node
#
# source://prism//lib/prism/mutation_compiler.rb#510
def visit_match_predicate_node(node); end
# Copy a MatchRequiredNode node
#
# source://prism//lib/prism/mutation_compiler.rb#515
def visit_match_required_node(node); end
# Copy a MatchWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#520
def visit_match_write_node(node); end
# Copy a MissingNode node
#
# source://prism//lib/prism/mutation_compiler.rb#525
def visit_missing_node(node); end
# Copy a ModuleNode node
#
# source://prism//lib/prism/mutation_compiler.rb#530
def visit_module_node(node); end
# Copy a MultiTargetNode node
#
# source://prism//lib/prism/mutation_compiler.rb#535
def visit_multi_target_node(node); end
# Copy a MultiWriteNode node
#
# source://prism//lib/prism/mutation_compiler.rb#540
def visit_multi_write_node(node); end
# Copy a NextNode node
#
# source://prism//lib/prism/mutation_compiler.rb#545
def visit_next_node(node); end
# Copy a NilNode node
#
# source://prism//lib/prism/mutation_compiler.rb#550
def visit_nil_node(node); end
# Copy a NoKeywordsParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#555
def visit_no_keywords_parameter_node(node); end
# Copy a NumberedParametersNode node
#
# source://prism//lib/prism/mutation_compiler.rb#560
def visit_numbered_parameters_node(node); end
# Copy a NumberedReferenceReadNode node
#
# source://prism//lib/prism/mutation_compiler.rb#565
def visit_numbered_reference_read_node(node); end
# Copy a OptionalKeywordParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#570
def visit_optional_keyword_parameter_node(node); end
# Copy a OptionalParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#575
def visit_optional_parameter_node(node); end
# Copy a OrNode node
#
# source://prism//lib/prism/mutation_compiler.rb#580
def visit_or_node(node); end
# Copy a ParametersNode node
#
# source://prism//lib/prism/mutation_compiler.rb#585
def visit_parameters_node(node); end
# Copy a ParenthesesNode node
#
# source://prism//lib/prism/mutation_compiler.rb#590
def visit_parentheses_node(node); end
# Copy a PinnedExpressionNode node
#
# source://prism//lib/prism/mutation_compiler.rb#595
def visit_pinned_expression_node(node); end
# Copy a PinnedVariableNode node
#
# source://prism//lib/prism/mutation_compiler.rb#600
def visit_pinned_variable_node(node); end
# Copy a PostExecutionNode node
#
# source://prism//lib/prism/mutation_compiler.rb#605
def visit_post_execution_node(node); end
# Copy a PreExecutionNode node
#
# source://prism//lib/prism/mutation_compiler.rb#610
def visit_pre_execution_node(node); end
# Copy a ProgramNode node
#
# source://prism//lib/prism/mutation_compiler.rb#615
def visit_program_node(node); end
# Copy a RangeNode node
#
# source://prism//lib/prism/mutation_compiler.rb#620
def visit_range_node(node); end
# Copy a RationalNode node
#
# source://prism//lib/prism/mutation_compiler.rb#625
def visit_rational_node(node); end
# Copy a RedoNode node
#
# source://prism//lib/prism/mutation_compiler.rb#630
def visit_redo_node(node); end
# Copy a RegularExpressionNode node
#
# source://prism//lib/prism/mutation_compiler.rb#635
def visit_regular_expression_node(node); end
# Copy a RequiredKeywordParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#640
def visit_required_keyword_parameter_node(node); end
# Copy a RequiredParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#645
def visit_required_parameter_node(node); end
# Copy a RescueModifierNode node
#
# source://prism//lib/prism/mutation_compiler.rb#650
def visit_rescue_modifier_node(node); end
# Copy a RescueNode node
#
# source://prism//lib/prism/mutation_compiler.rb#655
def visit_rescue_node(node); end
# Copy a RestParameterNode node
#
# source://prism//lib/prism/mutation_compiler.rb#660
def visit_rest_parameter_node(node); end
# Copy a RetryNode node
#
# source://prism//lib/prism/mutation_compiler.rb#665
def visit_retry_node(node); end
# Copy a ReturnNode node
#
# source://prism//lib/prism/mutation_compiler.rb#670
def visit_return_node(node); end
# Copy a SelfNode node
#
# source://prism//lib/prism/mutation_compiler.rb#675
def visit_self_node(node); end
# Copy a ShareableConstantNode node
#
# source://prism//lib/prism/mutation_compiler.rb#680
def visit_shareable_constant_node(node); end
# Copy a SingletonClassNode node
#
# source://prism//lib/prism/mutation_compiler.rb#685
def visit_singleton_class_node(node); end
# Copy a SourceEncodingNode node
#
# source://prism//lib/prism/mutation_compiler.rb#690
def visit_source_encoding_node(node); end
# Copy a SourceFileNode node
#
# source://prism//lib/prism/mutation_compiler.rb#695
def visit_source_file_node(node); end
# Copy a SourceLineNode node
#
# source://prism//lib/prism/mutation_compiler.rb#700
def visit_source_line_node(node); end
# Copy a SplatNode node
#
# source://prism//lib/prism/mutation_compiler.rb#705
def visit_splat_node(node); end
# Copy a StatementsNode node
#
# source://prism//lib/prism/mutation_compiler.rb#710
def visit_statements_node(node); end
# Copy a StringNode node
#
# source://prism//lib/prism/mutation_compiler.rb#715
def visit_string_node(node); end
# Copy a SuperNode node
#
# source://prism//lib/prism/mutation_compiler.rb#720
def visit_super_node(node); end
# Copy a SymbolNode node
#
# source://prism//lib/prism/mutation_compiler.rb#725
def visit_symbol_node(node); end
# Copy a TrueNode node
#
# source://prism//lib/prism/mutation_compiler.rb#730
def visit_true_node(node); end
# Copy a UndefNode node
#
# source://prism//lib/prism/mutation_compiler.rb#735
def visit_undef_node(node); end
# Copy a UnlessNode node
#
# source://prism//lib/prism/mutation_compiler.rb#740
def visit_unless_node(node); end
# Copy a UntilNode node
#
# source://prism//lib/prism/mutation_compiler.rb#745
def visit_until_node(node); end
# Copy a WhenNode node
#
# source://prism//lib/prism/mutation_compiler.rb#750
def visit_when_node(node); end
# Copy a WhileNode node
#
# source://prism//lib/prism/mutation_compiler.rb#755
def visit_while_node(node); end
# Copy a XStringNode node
#
# source://prism//lib/prism/mutation_compiler.rb#760
def visit_x_string_node(node); end
# Copy a YieldNode node
#
# source://prism//lib/prism/mutation_compiler.rb#765
def visit_yield_node(node); end
end
# Represents the use of the `next` keyword.
#
# next 1
# ^^^^^^
#
# source://prism//lib/prism/node.rb#13689
class Prism::NextNode < ::Prism::Node
# def initialize: (ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
#
# @return [NextNode] a new instance of NextNode
#
# source://prism//lib/prism/node.rb#13691
sig do
params(
source: Prism::Source,
arguments: T.nilable(Prism::ArgumentsNode),
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, arguments, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13783
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13699
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#13734
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13704
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13716
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13709
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> NextNode
#
# source://prism//lib/prism/node.rb#13721
sig do
params(
arguments: T.nilable(Prism::ArgumentsNode),
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::NextNode)
end
def copy(arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13704
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#13729
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13749
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#13744
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#13737
sig { returns(Prism::Location) }
def keyword_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13767
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13777
def type; end
end
end
# Represents the use of the `nil` keyword.
#
# nil
# ^^^
#
# source://prism//lib/prism/node.rb#13794
class Prism::NilNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [NilNode] a new instance of NilNode
#
# source://prism//lib/prism/node.rb#13796
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13869
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13802
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13807
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13817
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13812
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> NilNode
#
# source://prism//lib/prism/node.rb#13822
sig { params(location: Prism::Location).returns(Prism::NilNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13807
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#13830
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13835
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13853
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13863
def type; end
end
end
# Represents the use of `**nil` inside method arguments.
#
# def a(**nil)
# ^^^^^
# end
#
# source://prism//lib/prism/node.rb#13879
class Prism::NoKeywordsParameterNode < ::Prism::Node
# def initialize: (Location operator_loc, Location keyword_loc, Location location) -> void
#
# @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode
#
# source://prism//lib/prism/node.rb#13881
sig do
params(
source: Prism::Source,
operator_loc: Prism::Location,
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, operator_loc, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#13980
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#13889
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13894
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#13904
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#13899
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?operator_loc: Location, ?keyword_loc: Location, ?location: Location) -> NoKeywordsParameterNode
#
# source://prism//lib/prism/node.rb#13909
sig do
params(
operator_loc: Prism::Location,
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::NoKeywordsParameterNode)
end
def copy(operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#13894
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#13917
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#13946
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#13941
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#13929
sig { returns(Prism::Location) }
def keyword_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#13936
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#13922
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13964
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#13974
def type; end
end
end
# This represents a node in the tree. It is the parent class of all of the
# various node types.
#
# source://prism//lib/prism/node.rb#12
class Prism::Node
abstract!
# Accepts a visitor and calls back into the specialized visit function.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#131
sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# Returns an array of child nodes, including `nil`s in the place of optional
# nodes that were not present.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#137
sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# Returns an array of child nodes and locations that could potentially have
# comments attached to them.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#151
sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# Returns an array of child nodes, excluding any `nil`s in the place of
# optional nodes that were not present.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#145
sig { abstract.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# Returns an array of child nodes, including `nil`s in the place of optional
# nodes that were not present.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#137
sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# source://prism//lib/prism/node_ext.rb#7
def deprecated(*replacements); end
# The end offset of the node in the source. This method is effectively a
# delegate method to the location object.
#
# source://prism//lib/prism/node.rb#34
sig { returns(Integer) }
def end_offset; end
sig { abstract.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Returns a string representation of the node.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#162
sig { abstract.returns(String) }
def inspect; end
# A Location instance that represents the location of this node in the
# source.
#
# source://prism//lib/prism/node.rb#19
sig { returns(Prism::Location) }
def location; end
# source://prism//lib/prism/parse_result/newlines.rb#69
def newline!(lines); end
# @return [Boolean]
#
# source://prism//lib/prism/parse_result/newlines.rb#65
def newline?; end
# Similar to inspect, but respects the current level of indentation given by
# the pretty print object.
#
# source://prism//lib/prism/node.rb#62
sig { params(q: T.untyped).void }
def pretty_print(q); end
# Returns all of the lines of the source code associated with this node.
# An alias for source_lines, used to mimic the API from
# RubyVM::AbstractSyntaxTree to make it easier to migrate.
#
# source://prism//lib/prism/node.rb#40
sig { returns(T::Array[String]) }
def script_lines; end
# Slice the location of the node from the source.
#
# source://prism//lib/prism/node.rb#49
sig { returns(String) }
def slice; end
# Slice the location of the node from the source, starting at the beginning
# of the line that the location starts on, ending at the end of the line
# that the location ends on.
#
# source://prism//lib/prism/node.rb#56
sig { returns(String) }
def slice_lines; end
# Returns all of the lines of the source code associated with this node.
#
# source://prism//lib/prism/node.rb#40
sig { returns(T::Array[String]) }
def source_lines; end
# The start offset of the node in the source. This method is effectively a
# delegate method to the location object.
#
# source://prism//lib/prism/node.rb#27
sig { returns(Integer) }
def start_offset; end
# Convert this node into a graphviz dot graph string.
#
# source://prism//lib/prism/node.rb#70
sig { returns(String) }
def to_dot; end
# Returns a list of nodes that are descendants of this node that contain the
# given line and column. This is useful for locating a node that is selected
# based on the line and column of the source code.
#
# Important to note is that the column given to this method should be in
# bytes, as opposed to characters or code units.
#
# source://prism//lib/prism/node.rb#81
sig { params(line: Integer, column: Integer).returns(T::Array[Prism::Node]) }
def tunnel(line, column); end
# Returns a symbol symbolizing the type of node that this represents. This
# is particularly useful for case statements and array comparisons.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#157
sig { abstract.returns(Symbol) }
def type; end
private
# A pointer to the source that this node was created from.
#
# source://prism//lib/prism/node.rb#14
sig { returns(Prism::Source) }
def source; end
class << self
# Returns a list of the fields that exist for this node class. Fields
# describe the structure of the node. This kind of reflection is useful for
# things like recursively visiting each node _and_ field in the tree.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#115
def fields; end
# Returns the type of the node as a symbol.
#
# @raise [NoMethodError]
#
# source://prism//lib/prism/node.rb#167
def type; end
end
end
# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
#
# -> { _1 + _2 }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#13991
class Prism::NumberedParametersNode < ::Prism::Node
# def initialize: (Integer maximum, Location location) -> void
#
# @return [NumberedParametersNode] a new instance of NumberedParametersNode
#
# source://prism//lib/prism/node.rb#13993
sig { params(source: Prism::Source, maximum: Integer, location: Prism::Location).void }
def initialize(source, maximum, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14070
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14000
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14005
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14015
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14010
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?maximum: Integer, ?location: Location) -> NumberedParametersNode
#
# source://prism//lib/prism/node.rb#14020
sig { params(maximum: Integer, location: Prism::Location).returns(Prism::NumberedParametersNode) }
def copy(maximum: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14005
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { maximum: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#14028
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14036
sig { override.returns(String) }
def inspect; end
# attr_reader maximum: Integer
#
# source://prism//lib/prism/node.rb#14033
sig { returns(Integer) }
def maximum; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14054
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14064
def type; end
end
end
# Represents reading a numbered reference to a capture in the previous match.
#
# $1
# ^^
#
# source://prism//lib/prism/node.rb#14080
class Prism::NumberedReferenceReadNode < ::Prism::Node
# def initialize: (Integer number, Location location) -> void
#
# @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode
#
# source://prism//lib/prism/node.rb#14082
sig { params(source: Prism::Source, number: Integer, location: Prism::Location).void }
def initialize(source, number, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14165
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14089
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14094
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14104
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14099
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?number: Integer, ?location: Location) -> NumberedReferenceReadNode
#
# source://prism//lib/prism/node.rb#14109
sig { params(number: Integer, location: Prism::Location).returns(Prism::NumberedReferenceReadNode) }
def copy(number: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14094
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { number: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#14117
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14131
sig { override.returns(String) }
def inspect; end
# The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
#
# $1 # number `1`
#
# $5432 # number `5432`
#
# $4294967296 # number `0`
#
# source://prism//lib/prism/node.rb#14128
sig { returns(Integer) }
def number; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14149
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14159
def type; end
end
end
# Represents an optional keyword parameter to a method, block, or lambda definition.
#
# def a(b: 1)
# ^^^^
# end
#
# source://prism//lib/prism/node.rb#14176
class Prism::OptionalKeywordParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol name, Location name_loc, Prism::node value, Location location) -> void
#
# @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode
#
# source://prism//lib/prism/node.rb#14178
sig do
params(
source: Prism::Source,
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14277
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14188
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14193
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14203
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14198
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalKeywordParameterNode
#
# source://prism//lib/prism/node.rb#14208
sig do
params(
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::OptionalKeywordParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14193
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#14216
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14243
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#14225
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#14228
sig { returns(Prism::Location) }
def name_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#14238
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14261
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#14235
sig { returns(Prism::Node) }
def value; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#14221
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14271
def type; end
end
end
# Represents an optional parameter to a method, block, or lambda definition.
#
# def a(b = 1)
# ^^^^^
# end
#
# source://prism//lib/prism/node.rb#14291
class Prism::OptionalParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
#
# @return [OptionalParameterNode] a new instance of OptionalParameterNode
#
# source://prism//lib/prism/node.rb#14293
sig do
params(
source: Prism::Source,
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, operator_loc, value, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14405
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14304
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14319
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14314
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalParameterNode
#
# source://prism//lib/prism/node.rb#14324
sig do
params(
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
operator_loc: Prism::Location,
value: Prism::Node,
location: Prism::Location
).returns(Prism::OptionalParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14309
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#14332
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14371
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#14341
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#14344
sig { returns(Prism::Location) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#14366
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#14351
sig { returns(Prism::Location) }
def operator_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#14361
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14389
sig { override.returns(Symbol) }
def type; end
# attr_reader value: Prism::node
#
# source://prism//lib/prism/node.rb#14358
sig { returns(Prism::Node) }
def value; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#14337
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14399
def type; end
end
end
# Represents the use of the `||` operator or the `or` keyword.
#
# left or right
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#14419
class Prism::OrNode < ::Prism::Node
# def initialize: (Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
#
# @return [OrNode] a new instance of OrNode
#
# source://prism//lib/prism/node.rb#14421
sig do
params(
source: Prism::Source,
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, left, right, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14530
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14430
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14435
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14445
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14440
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> OrNode
#
# source://prism//lib/prism/node.rb#14450
sig do
params(
left: Prism::Node,
right: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::OrNode)
end
def copy(left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14435
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#14458
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14496
sig { override.returns(String) }
def inspect; end
# Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# left or right
# ^^^^
#
# 1 || 2
# ^
#
# source://prism//lib/prism/node.rb#14469
sig { returns(Prism::Node) }
def left; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#14491
sig { returns(String) }
def operator; end
# The location of the `or` keyword or the `||` operator.
#
# left or right
# ^^
#
# source://prism//lib/prism/node.rb#14484
sig { returns(Prism::Location) }
def operator_loc; end
# Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# left || right
# ^^^^^
#
# 1 or 2
# ^
#
# source://prism//lib/prism/node.rb#14478
sig { returns(Prism::Node) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14514
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14524
def type; end
end
end
# A parser for the pack template language.
#
# source://prism//lib/prism/pack.rb#6
module Prism::Pack
class << self
def parse(_arg0, _arg1, _arg2); end
end
end
# source://prism//lib/prism/pack.rb#56
Prism::Pack::AGNOSTIC_ENDIAN = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::BACK = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::BER = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::BIG_ENDIAN = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::COMMENT = T.let(T.unsafe(nil), Symbol)
# A directive in the pack template language.
#
# source://prism//lib/prism/pack.rb#60
class Prism::Pack::Directive
# Initialize a new directive with the given values.
#
# @return [Directive] a new instance of Directive
#
# source://prism//lib/prism/pack.rb#89
def initialize(version, variant, source, type, signed, endian, size, length_type, length); end
# Provide a human-readable description of the directive.
#
# source://prism//lib/prism/pack.rb#131
def describe; end
# The type of endianness of the directive.
#
# source://prism//lib/prism/pack.rb#77
def endian; end
# The length of this directive (used for integers).
#
# source://prism//lib/prism/pack.rb#86
def length; end
# The length type of this directive (used for integers).
#
# source://prism//lib/prism/pack.rb#83
def length_type; end
# The type of signedness of the directive.
#
# source://prism//lib/prism/pack.rb#74
def signed; end
# The size of the directive.
#
# source://prism//lib/prism/pack.rb#80
def size; end
# A byteslice of the source string that this directive represents.
#
# source://prism//lib/prism/pack.rb#68
def source; end
# The type of the directive.
#
# source://prism//lib/prism/pack.rb#71
def type; end
# A symbol representing whether or not we are packing or unpacking.
#
# source://prism//lib/prism/pack.rb#65
def variant; end
# A symbol representing the version of Ruby.
#
# source://prism//lib/prism/pack.rb#62
def version; end
end
# The descriptions of the various types of endianness.
#
# source://prism//lib/prism/pack.rb#102
Prism::Pack::Directive::ENDIAN_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
# The descriptions of the various types of signedness.
#
# source://prism//lib/prism/pack.rb#111
Prism::Pack::Directive::SIGNED_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
# The descriptions of the various types of sizes.
#
# source://prism//lib/prism/pack.rb#118
Prism::Pack::Directive::SIZE_DESCRIPTIONS = T.let(T.unsafe(nil), Hash)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::ENDIAN_NA = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::FLOAT = T.let(T.unsafe(nil), Symbol)
# The result of parsing a pack template.
#
# source://prism//lib/prism/pack.rb#198
class Prism::Pack::Format
# Create a new Format with the given directives and encoding.
#
# @return [Format] a new instance of Format
#
# source://prism//lib/prism/pack.rb#206
def initialize(directives, encoding); end
# Provide a human-readable description of the format.
#
# source://prism//lib/prism/pack.rb#212
def describe; end
# A list of the directives in the template.
#
# source://prism//lib/prism/pack.rb#200
def directives; end
# The encoding of the template.
#
# source://prism//lib/prism/pack.rb#203
def encoding; end
end
# source://prism//lib/prism/pack.rb#56
Prism::Pack::INTEGER = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::LENGTH_FIXED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::LENGTH_MAX = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::LENGTH_NA = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::LENGTH_RELATIVE = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::LITTLE_ENDIAN = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::MOVE = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::NATIVE_ENDIAN = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::NULL = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIGNED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIGNED_NA = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_16 = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_32 = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_64 = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_8 = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_INT = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_LONG = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_LONG_LONG = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_NA = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_P = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SIZE_SHORT = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::SPACE = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_BASE64 = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_FIXED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_HEX_HIGH = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_HEX_LOW = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_LSB = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_MIME = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_MSB = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_NULL_PADDED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_NULL_TERMINATED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_POINTER = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_SPACE_PADDED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::STRING_UU = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::UNSIGNED = T.let(T.unsafe(nil), Symbol)
# source://prism//lib/prism/pack.rb#56
Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol)
# Flags for parameter nodes.
#
# source://prism//lib/prism/node.rb#19202
module Prism::ParameterFlags; end
# a parameter name that has been repeated in the method signature
#
# source://prism//lib/prism/node.rb#19204
Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer)
# Represents the list of parameters on a method, block, or lambda definition.
#
# def a(b, c, d)
# ^^^^^^^
# end
#
# source://prism//lib/prism/node.rb#14543
class Prism::ParametersNode < ::Prism::Node
# def initialize: (Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
#
# @return [ParametersNode] a new instance of ParametersNode
#
# source://prism//lib/prism/node.rb#14545
sig do
params(
source: Prism::Source,
requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
optionals: T::Array[Prism::OptionalParameterNode],
rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
block: T.nilable(Prism::BlockParameterNode),
location: Prism::Location
).void
end
def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14654
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14558
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader block: BlockParameterNode?
#
# source://prism//lib/prism/node.rb#14617
sig { returns(T.nilable(Prism::BlockParameterNode)) }
def block; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14563
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14581
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14568
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
#
# source://prism//lib/prism/node.rb#14586
sig do
params(
requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)],
optionals: T::Array[Prism::OptionalParameterNode],
rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)),
posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)],
keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)],
keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)),
block: T.nilable(Prism::BlockParameterNode),
location: Prism::Location
).returns(Prism::ParametersNode)
end
def copy(requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14563
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
#
# source://prism//lib/prism/node.rb#14594
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14620
sig { override.returns(String) }
def inspect; end
# attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
#
# source://prism//lib/prism/node.rb#14614
sig do
returns(T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)))
end
def keyword_rest; end
# attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
#
# source://prism//lib/prism/node.rb#14611
sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) }
def keywords; end
# attr_reader optionals: Array[OptionalParameterNode]
#
# source://prism//lib/prism/node.rb#14602
sig { returns(T::Array[Prism::OptionalParameterNode]) }
def optionals; end
# attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
#
# source://prism//lib/prism/node.rb#14608
sig do
returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)])
end
def posts; end
# attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
#
# source://prism//lib/prism/node.rb#14599
sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)]) }
def requireds; end
# attr_reader rest: RestParameterNode | ImplicitRestNode | nil
#
# source://prism//lib/prism/node.rb#14605
sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) }
def rest; end
# Mirrors the Method#parameters method.
#
# source://prism//lib/prism/node_ext.rb#253
sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
def signature; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14638
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14648
def type; end
end
end
# Represents a parenthesized expression
#
# (10 + 34)
# ^^^^^^^^^
#
# source://prism//lib/prism/node.rb#14674
class Prism::ParenthesesNode < ::Prism::Node
# def initialize: (Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
#
# @return [ParenthesesNode] a new instance of ParenthesesNode
#
# source://prism//lib/prism/node.rb#14676
sig do
params(
source: Prism::Source,
body: T.nilable(Prism::Node),
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, body, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14781
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14685
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#14720
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14690
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#14742
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#14730
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14702
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14695
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> ParenthesesNode
#
# source://prism//lib/prism/node.rb#14707
sig do
params(
body: T.nilable(Prism::Node),
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::ParenthesesNode)
end
def copy(body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14690
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#14715
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14747
sig { override.returns(String) }
def inspect; end
# source://prism//lib/prism/parse_result/newlines.rb#85
def newline!(lines); end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#14737
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#14723
sig { returns(Prism::Location) }
def opening_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14765
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14775
def type; end
end
end
# This represents an error that was encountered during parsing.
#
# source://prism//lib/prism/parse_result.rb#451
class Prism::ParseError
# Create a new error object with the given message and location.
#
# @return [ParseError] a new instance of ParseError
#
# source://prism//lib/prism/parse_result.rb#466
sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
def initialize(type, message, location, level); end
# Implement the hash pattern matching interface for ParseError.
#
# source://prism//lib/prism/parse_result.rb#474
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Returns a string representation of this error.
#
# source://prism//lib/prism/parse_result.rb#479
sig { returns(String) }
def inspect; end
# The level of this error.
#
# source://prism//lib/prism/parse_result.rb#463
sig { returns(Symbol) }
def level; end
# A Location object representing the location of this error in the source.
#
# source://prism//lib/prism/parse_result.rb#460
sig { returns(Prism::Location) }
def location; end
# The message associated with this error.
#
# source://prism//lib/prism/parse_result.rb#457
sig { returns(String) }
def message; end
# The type of error. This is an _internal_ symbol that is used for
# communicating with translation layers. It is not meant to be public API.
#
# source://prism//lib/prism/parse_result.rb#454
sig { returns(Symbol) }
def type; end
end
# This is a result specific to the `parse_lex` and `parse_lex_file` methods.
#
# source://prism//lib/prism/parse_result.rb#627
class Prism::ParseLexResult < ::Prism::Result
# Create a new parse lex result object with the given values.
#
# @return [ParseLexResult] a new instance of ParseLexResult
#
# source://prism//lib/prism/parse_result.rb#633
sig do
params(
value: [Prism::ProgramNode, T::Array[T.untyped]],
comments: T::Array[Prism::Comment],
magic_comments: T::Array[Prism::MagicComment],
data_loc: T.nilable(Prism::Location),
errors: T::Array[Prism::ParseError],
warnings: T::Array[Prism::ParseWarning],
source: Prism::Source
).void
end
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
# Implement the hash pattern matching interface for ParseLexResult.
#
# source://prism//lib/prism/parse_result.rb#639
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# A tuple of the syntax tree and the list of tokens that were parsed from
# the source code.
#
# source://prism//lib/prism/parse_result.rb#630
sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) }
def value; end
end
# This is a result specific to the `parse` and `parse_file` methods.
#
# source://prism//lib/prism/parse_result.rb#576
class Prism::ParseResult < ::Prism::Result
# Create a new parse result object with the given values.
#
# @return [ParseResult] a new instance of ParseResult
#
# source://prism//lib/prism/parse_result.rb#587
sig do
params(
value: Prism::ProgramNode,
comments: T::Array[Prism::Comment],
magic_comments: T::Array[Prism::MagicComment],
data_loc: T.nilable(Prism::Location),
errors: T::Array[Prism::ParseError],
warnings: T::Array[Prism::ParseWarning],
source: Prism::Source
).void
end
def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end
# Attach the list of comments to their respective locations in the tree.
#
# source://prism//lib/prism/parse_result.rb#598
def attach_comments!; end
# Implement the hash pattern matching interface for ParseResult.
#
# source://prism//lib/prism/parse_result.rb#593
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Walk the tree and mark nodes that are on a new line, loosely emulating
# the behavior of CRuby's `:line` tracepoint event.
#
# source://prism//lib/prism/parse_result.rb#604
def mark_newlines!; end
# The syntax tree that was parsed from the source code.
#
# source://prism//lib/prism/parse_result.rb#584
sig { returns(Prism::ProgramNode) }
def value; end
end
# When we've parsed the source, we have both the syntax tree and the list of
# comments that we found in the source. This class is responsible for
# walking the tree and finding the nearest location to attach each comment.
#
# It does this by first finding the nearest locations to each comment.
# Locations can either come from nodes directly or from location fields on
# nodes. For example, a `ClassNode` has an overall location encompassing the
# entire class, but it also has a location for the `class` keyword.
#
# Once the nearest locations are found, it determines which one to attach
# to. If it's a trailing comment (a comment on the same line as other source
# code), it will favor attaching to the nearest location that occurs before
# the comment. Otherwise it will favor attaching to the nearest location
# that is after the comment.
#
# source://prism//lib/prism/parse_result/comments.rb#19
class Prism::ParseResult::Comments
# Create a new Comments object that will attach comments to the given
# parse result.
#
# @return [Comments] a new instance of Comments
#
# source://prism//lib/prism/parse_result/comments.rb#86
def initialize(parse_result); end
# Attach the comments to their respective locations in the tree by
# mutating the parse result.
#
# source://prism//lib/prism/parse_result/comments.rb#92
def attach!; end
# The parse result that we are attaching comments to.
#
# source://prism//lib/prism/parse_result/comments.rb#82
def parse_result; end
private
# Responsible for finding the nearest targets to the given comment within
# the context of the given encapsulating node.
#
# source://prism//lib/prism/parse_result/comments.rb#119
def nearest_targets(node, comment); end
end
# A target for attaching comments that is based on a location field on a
# node. For example, the `end` token of a ClassNode.
#
# source://prism//lib/prism/parse_result/comments.rb#53
class Prism::ParseResult::Comments::LocationTarget
# @return [LocationTarget] a new instance of LocationTarget
#
# source://prism//lib/prism/parse_result/comments.rb#56
def initialize(location); end
# @return [Boolean]
#
# source://prism//lib/prism/parse_result/comments.rb#68
def encloses?(comment); end
# source://prism//lib/prism/parse_result/comments.rb#64
def end_offset; end
# source://prism//lib/prism/parse_result/comments.rb#72
def leading_comment(comment); end
# source://prism//lib/prism/parse_result/comments.rb#54
def location; end
# source://prism//lib/prism/parse_result/comments.rb#60
def start_offset; end
# source://prism//lib/prism/parse_result/comments.rb#76
def trailing_comment(comment); end
end
# A target for attaching comments that is based on a specific node's
# location.
#
# source://prism//lib/prism/parse_result/comments.rb#22
class Prism::ParseResult::Comments::NodeTarget
# @return [NodeTarget] a new instance of NodeTarget
#
# source://prism//lib/prism/parse_result/comments.rb#25
def initialize(node); end
# @return [Boolean]
#
# source://prism//lib/prism/parse_result/comments.rb#37
def encloses?(comment); end
# source://prism//lib/prism/parse_result/comments.rb#33
def end_offset; end
# source://prism//lib/prism/parse_result/comments.rb#42
def leading_comment(comment); end
# source://prism//lib/prism/parse_result/comments.rb#23
def node; end
# source://prism//lib/prism/parse_result/comments.rb#29
def start_offset; end
# source://prism//lib/prism/parse_result/comments.rb#46
def trailing_comment(comment); end
end
# The :line tracepoint event gets fired whenever the Ruby VM encounters an
# expression on a new line. The types of expressions that can trigger this
# event are:
#
# * if statements
# * unless statements
# * nodes that are children of statements lists
#
# In order to keep track of the newlines, we have a list of offsets that
# come back from the parser. We assign these offsets to the first nodes that
# we find in the tree that are on those lines.
#
# Note that the logic in this file should be kept in sync with the Java
# MarkNewlinesVisitor, since that visitor is responsible for marking the
# newlines for JRuby/TruffleRuby.
#
# This file is autoloaded only when `mark_newlines!` is called, so the
# re-opening of the various nodes in this file will only be performed in
# that case. We do that to avoid storing the extra `@newline` instance
# variable on every node if we don't need it.
#
# source://prism//lib/prism/parse_result/newlines.rb#25
class Prism::ParseResult::Newlines < ::Prism::Visitor
# Create a new Newlines visitor with the given newline offsets.
#
# @return [Newlines] a new instance of Newlines
#
# source://prism//lib/prism/parse_result/newlines.rb#27
def initialize(lines); end
# Permit block/lambda nodes to mark newlines within themselves.
#
# source://prism//lib/prism/parse_result/newlines.rb#33
def visit_block_node(node); end
# Mark if/unless nodes as newlines.
#
# source://prism//lib/prism/parse_result/newlines.rb#47
def visit_if_node(node); end
# Permit block/lambda nodes to mark newlines within themselves.
#
# source://prism//lib/prism/parse_result/newlines.rb#33
def visit_lambda_node(node); end
# Permit statements lists to mark newlines within themselves.
#
# source://prism//lib/prism/parse_result/newlines.rb#55
def visit_statements_node(node); end
# Mark if/unless nodes as newlines.
#
# source://prism//lib/prism/parse_result/newlines.rb#47
def visit_unless_node(node); end
end
# This represents a warning that was encountered during parsing.
#
# source://prism//lib/prism/parse_result.rb#485
class Prism::ParseWarning
# Create a new warning object with the given message and location.
#
# @return [ParseWarning] a new instance of ParseWarning
#
# source://prism//lib/prism/parse_result.rb#500
sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void }
def initialize(type, message, location, level); end
# Implement the hash pattern matching interface for ParseWarning.
#
# source://prism//lib/prism/parse_result.rb#508
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Returns a string representation of this warning.
#
# source://prism//lib/prism/parse_result.rb#513
sig { returns(String) }
def inspect; end
# The level of this warning.
#
# source://prism//lib/prism/parse_result.rb#497
sig { returns(Symbol) }
def level; end
# A Location object representing the location of this warning in the source.
#
# source://prism//lib/prism/parse_result.rb#494
sig { returns(Prism::Location) }
def location; end
# The message associated with this warning.
#
# source://prism//lib/prism/parse_result.rb#491
sig { returns(String) }
def message; end
# The type of warning. This is an _internal_ symbol that is used for
# communicating with translation layers. It is not meant to be public API.
#
# source://prism//lib/prism/parse_result.rb#488
sig { returns(Symbol) }
def type; end
end
# A pattern is an object that wraps a Ruby pattern matching expression. The
# expression would normally be passed to an `in` clause within a `case`
# expression or a rightward assignment expression. For example, in the
# following snippet:
#
# case node
# in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
# end
#
# the pattern is the <tt>ConstantPathNode[...]</tt> expression.
#
# The pattern gets compiled into an object that responds to #call by running
# the #compile method. This method itself will run back through Prism to
# parse the expression into a tree, then walk the tree to generate the
# necessary callable objects. For example, if you wanted to compile the
# expression above into a callable, you would:
#
# callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
# callable.call(node)
#
# The callable object returned by #compile is guaranteed to respond to #call
# with a single argument, which is the node to match against. It also is
# guaranteed to respond to #===, which means it itself can be used in a `case`
# expression, as in:
#
# case node
# when callable
# end
#
# If the query given to the initializer cannot be compiled into a valid
# matcher (either because of a syntax error or because it is using syntax we
# do not yet support) then a Prism::Pattern::CompilationError will be
# raised.
#
# source://prism//lib/prism/pattern.rb#37
class Prism::Pattern
# Create a new pattern with the given query. The query should be a string
# containing a Ruby pattern matching expression.
#
# @return [Pattern] a new instance of Pattern
#
# source://prism//lib/prism/pattern.rb#63
def initialize(query); end
# Compile the query into a callable object that can be used to match against
# nodes.
#
# @raise [CompilationError]
#
# source://prism//lib/prism/pattern.rb#70
def compile; end
# The query that this pattern was initialized with.
#
# source://prism//lib/prism/pattern.rb#59
def query; end
# Scan the given node and all of its children for nodes that match the
# pattern. If a block is given, it will be called with each node that
# matches the pattern. If no block is given, an enumerator will be returned
# that will yield each node that matches the pattern.
#
# source://prism//lib/prism/pattern.rb#86
def scan(root); end
private
# Shortcut for combining two procs into one that returns true if both return
# true.
#
# source://prism//lib/prism/pattern.rb#102
def combine_and(left, right); end
# Shortcut for combining two procs into one that returns true if either
# returns true.
#
# source://prism//lib/prism/pattern.rb#108
def combine_or(left, right); end
# in foo | bar
#
# source://prism//lib/prism/pattern.rb#143
def compile_alternation_pattern_node(node); end
# in [foo, bar, baz]
#
# source://prism//lib/prism/pattern.rb#118
def compile_array_pattern_node(node); end
# Compile a name associated with a constant.
#
# source://prism//lib/prism/pattern.rb#168
def compile_constant_name(node, name); end
# in Prism::ConstantReadNode
#
# source://prism//lib/prism/pattern.rb#148
def compile_constant_path_node(node); end
# in ConstantReadNode
# in String
#
# source://prism//lib/prism/pattern.rb#163
def compile_constant_read_node(node); end
# Raise an error because the given node is not supported.
#
# @raise [CompilationError]
#
# source://prism//lib/prism/pattern.rb#113
def compile_error(node); end
# in InstanceVariableReadNode[name: Symbol]
# in { name: Symbol }
#
# source://prism//lib/prism/pattern.rb#184
def compile_hash_pattern_node(node); end
# in nil
#
# source://prism//lib/prism/pattern.rb#214
def compile_nil_node(node); end
# Compile any kind of node. Dispatch out to the individual compilation
# methods based on the type of node.
#
# source://prism//lib/prism/pattern.rb#243
def compile_node(node); end
# in /foo/
#
# source://prism//lib/prism/pattern.rb#219
def compile_regular_expression_node(node); end
# in ""
# in "foo"
#
# source://prism//lib/prism/pattern.rb#227
def compile_string_node(node); end
# in :+
# in :foo
#
# source://prism//lib/prism/pattern.rb#235
def compile_symbol_node(node); end
end
# Raised when the query given to a pattern is either invalid Ruby syntax or
# is using syntax that we don't yet support.
#
# source://prism//lib/prism/pattern.rb#40
class Prism::Pattern::CompilationError < ::StandardError
# Create a new CompilationError with the given representation of the node
# that caused the error.
#
# @return [CompilationError] a new instance of CompilationError
#
# source://prism//lib/prism/pattern.rb#43
def initialize(repr); end
end
# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
#
# foo in ^(bar)
# ^^^^^^
#
# source://prism//lib/prism/node.rb#14793
class Prism::PinnedExpressionNode < ::Prism::Node
# def initialize: (Prism::node expression, Location operator_loc, Location lparen_loc, Location rparen_loc, Location location) -> void
#
# @return [PinnedExpressionNode] a new instance of PinnedExpressionNode
#
# source://prism//lib/prism/node.rb#14795
sig do
params(
source: Prism::Source,
expression: Prism::Node,
operator_loc: Prism::Location,
lparen_loc: Prism::Location,
rparen_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, expression, operator_loc, lparen_loc, rparen_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#14911
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14805
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14810
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14820
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14815
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location, ?location: Location) -> PinnedExpressionNode
#
# source://prism//lib/prism/node.rb#14825
sig do
params(
expression: Prism::Node,
operator_loc: Prism::Location,
lparen_loc: Prism::Location,
rparen_loc: Prism::Location,
location: Prism::Location
).returns(Prism::PinnedExpressionNode)
end
def copy(expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14810
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#14833
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader expression: Prism::node
#
# source://prism//lib/prism/node.rb#14838
sig { returns(Prism::Node) }
def expression; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14877
sig { override.returns(String) }
def inspect; end
# def lparen: () -> String
#
# source://prism//lib/prism/node.rb#14867
sig { returns(String) }
def lparen; end
# attr_reader lparen_loc: Location
#
# source://prism//lib/prism/node.rb#14848
sig { returns(Prism::Location) }
def lparen_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#14862
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#14841
sig { returns(Prism::Location) }
def operator_loc; end
# def rparen: () -> String
#
# source://prism//lib/prism/node.rb#14872
sig { returns(String) }
def rparen; end
# attr_reader rparen_loc: Location
#
# source://prism//lib/prism/node.rb#14855
sig { returns(Prism::Location) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14895
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#14905
def type; end
end
end
# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
#
# foo in ^bar
# ^^^^
#
# source://prism//lib/prism/node.rb#14924
class Prism::PinnedVariableNode < ::Prism::Node
# def initialize: (Prism::node variable, Location operator_loc, Location location) -> void
#
# @return [PinnedVariableNode] a new instance of PinnedVariableNode
#
# source://prism//lib/prism/node.rb#14926
sig do
params(
source: Prism::Source,
variable: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, variable, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15016
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#14934
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14939
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#14949
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#14944
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?variable: Prism::node, ?operator_loc: Location, ?location: Location) -> PinnedVariableNode
#
# source://prism//lib/prism/node.rb#14954
sig do
params(
variable: Prism::Node,
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::PinnedVariableNode)
end
def copy(variable: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#14939
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { variable: Prism::node, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#14962
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#14982
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#14977
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#14970
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15000
sig { override.returns(Symbol) }
def type; end
# attr_reader variable: Prism::node
#
# source://prism//lib/prism/node.rb#14967
sig { returns(Prism::Node) }
def variable; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15010
def type; end
end
end
# Represents the use of the `END` keyword.
#
# END { foo }
# ^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#15027
class Prism::PostExecutionNode < ::Prism::Node
# def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
#
# @return [PostExecutionNode] a new instance of PostExecutionNode
#
# source://prism//lib/prism/node.rb#15029
sig do
params(
source: Prism::Source,
statements: T.nilable(Prism::StatementsNode),
keyword_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15147
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15039
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15044
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#15108
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#15091
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15056
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15049
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PostExecutionNode
#
# source://prism//lib/prism/node.rb#15061
sig do
params(
statements: T.nilable(Prism::StatementsNode),
keyword_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::PostExecutionNode)
end
def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15044
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#15069
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15113
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#15098
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#15077
sig { returns(Prism::Location) }
def keyword_loc; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#15103
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#15084
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#15074
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15131
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15141
def type; end
end
end
# Represents the use of the `BEGIN` keyword.
#
# BEGIN { foo }
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#15160
class Prism::PreExecutionNode < ::Prism::Node
# def initialize: (StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
#
# @return [PreExecutionNode] a new instance of PreExecutionNode
#
# source://prism//lib/prism/node.rb#15162
sig do
params(
source: Prism::Source,
statements: T.nilable(Prism::StatementsNode),
keyword_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, statements, keyword_loc, opening_loc, closing_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15280
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15172
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15177
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#15241
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#15224
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15189
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15182
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PreExecutionNode
#
# source://prism//lib/prism/node.rb#15194
sig do
params(
statements: T.nilable(Prism::StatementsNode),
keyword_loc: Prism::Location,
opening_loc: Prism::Location,
closing_loc: Prism::Location,
location: Prism::Location
).returns(Prism::PreExecutionNode)
end
def copy(statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15177
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#15202
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15246
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#15231
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#15210
sig { returns(Prism::Location) }
def keyword_loc; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#15236
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#15217
sig { returns(Prism::Location) }
def opening_loc; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#15207
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15264
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15274
def type; end
end
end
# The top level node of any parse tree.
#
# source://prism//lib/prism/node.rb#15290
class Prism::ProgramNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, StatementsNode statements, Location location) -> void
#
# @return [ProgramNode] a new instance of ProgramNode
#
# source://prism//lib/prism/node.rb#15292
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
statements: Prism::StatementsNode,
location: Prism::Location
).void
end
def initialize(source, locals, statements, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15373
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15300
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15305
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15315
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15310
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?locals: Array[Symbol], ?statements: StatementsNode, ?location: Location) -> ProgramNode
#
# source://prism//lib/prism/node.rb#15320
sig do
params(
locals: T::Array[Symbol],
statements: Prism::StatementsNode,
location: Prism::Location
).returns(Prism::ProgramNode)
end
def copy(locals: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15305
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], statements: StatementsNode, location: Location }
#
# source://prism//lib/prism/node.rb#15328
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15339
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#15333
sig { returns(T::Array[Symbol]) }
def locals; end
# attr_reader statements: StatementsNode
#
# source://prism//lib/prism/node.rb#15336
sig { returns(Prism::StatementsNode) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15357
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15367
def type; end
end
end
# Flags for range and flip-flop nodes.
#
# source://prism//lib/prism/node.rb#19208
module Prism::RangeFlags; end
# ... operator
#
# source://prism//lib/prism/node.rb#19210
Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer)
# Represents the use of the `..` or `...` operators.
#
# 1..2
# ^^^^
#
# c if a =~ /left/ ... b =~ /right/
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#15388
class Prism::RangeNode < ::Prism::Node
# def initialize: (Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
#
# @return [RangeNode] a new instance of RangeNode
#
# source://prism//lib/prism/node.rb#15390
sig do
params(
source: Prism::Source,
flags: Integer,
left: T.nilable(Prism::Node),
right: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, left, right, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15510
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15400
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15405
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15418
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15410
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> RangeNode
#
# source://prism//lib/prism/node.rb#15423
sig do
params(
flags: Integer,
left: T.nilable(Prism::Node),
right: T.nilable(Prism::Node),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::RangeNode)
end
def copy(flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15405
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#15431
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def exclude_end?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15466
sig { returns(T::Boolean) }
def exclude_end?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15476
sig { override.returns(String) }
def inspect; end
# The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# 1...
# ^
#
# hello...goodbye
# ^^^^^
#
# source://prism//lib/prism/node.rb#15446
sig { returns(T.nilable(Prism::Node)) }
def left; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#15471
sig { returns(String) }
def operator; end
# The location of the `..` or `...` operator.
#
# source://prism//lib/prism/node.rb#15459
sig { returns(Prism::Location) }
def operator_loc; end
# The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# ..5
# ^
#
# 1...foo
# ^^^
# If neither right-hand or left-hand side was included, this will be a MissingNode.
#
# source://prism//lib/prism/node.rb#15456
sig { returns(T.nilable(Prism::Node)) }
def right; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15494
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#15436
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15504
def type; end
end
end
# Represents a rational number literal.
#
# 1.0r
# ^^^^
#
# source://prism//lib/prism/node.rb#15523
class Prism::RationalNode < ::Prism::Node
# def initialize: (Integer flags, Integer numerator, Integer denominator, Location location) -> void
#
# @return [RationalNode] a new instance of RationalNode
#
# source://prism//lib/prism/node.rb#15525
sig do
params(
source: Prism::Source,
flags: Integer,
numerator: Integer,
denominator: Integer,
location: Prism::Location
).void
end
def initialize(source, flags, numerator, denominator, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15635
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15534
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def binary?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15581
sig { returns(T::Boolean) }
def binary?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15539
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15549
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15544
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?numerator: Integer, ?denominator: Integer, ?location: Location) -> RationalNode
#
# source://prism//lib/prism/node.rb#15554
sig do
params(
flags: Integer,
numerator: Integer,
denominator: Integer,
location: Prism::Location
).returns(Prism::RationalNode)
end
def copy(flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil), location: T.unsafe(nil)); end
# def decimal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15586
sig { returns(T::Boolean) }
def decimal?; end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15539
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, numerator: Integer, denominator: Integer, location: Location }
#
# source://prism//lib/prism/node.rb#15562
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# The denominator of the rational number.
#
# 1.5r # denominator 2
#
# source://prism//lib/prism/node.rb#15578
sig { returns(Integer) }
def denominator; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def hexadecimal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15596
sig { returns(T::Boolean) }
def hexadecimal?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15601
sig { override.returns(String) }
def inspect; end
# The numerator of the rational number.
#
# 1.5r # numerator 3
#
# source://prism//lib/prism/node.rb#15573
sig { returns(Integer) }
def numerator; end
# Returns the value of the node as an IntegerNode or a FloatNode. This
# method is deprecated in favor of #value or #numerator/#denominator.
#
# source://prism//lib/prism/node_ext.rb#114
def numeric; end
# def octal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15591
sig { returns(T::Boolean) }
def octal?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15619
sig { override.returns(Symbol) }
def type; end
# Returns the value of the node as a Ruby Rational.
#
# source://prism//lib/prism/node_ext.rb#108
sig { returns(Rational) }
def value; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#15567
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15629
def type; end
end
end
# Represents the use of the `redo` keyword.
#
# redo
# ^^^^
#
# source://prism//lib/prism/node.rb#15647
class Prism::RedoNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [RedoNode] a new instance of RedoNode
#
# source://prism//lib/prism/node.rb#15649
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15722
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15655
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15660
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15670
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15665
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> RedoNode
#
# source://prism//lib/prism/node.rb#15675
sig { params(location: Prism::Location).returns(Prism::RedoNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15660
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#15683
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15688
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15706
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15716
def type; end
end
end
# The Reflection module provides the ability to reflect on the structure of
# the syntax tree itself, as opposed to looking at a single syntax tree. This
# is useful in metaprogramming contexts.
#
# source://prism//lib/prism/reflection.rb#13
module Prism::Reflection
class << self
# Returns the fields for the given node.
#
# source://prism//lib/prism/reflection.rb#104
sig { params(node: T.class_of(Prism::Node)).returns(T::Array[Prism::Reflection::Field]) }
def fields_for(node); end
end
end
# A constant field represents a constant value on a node. Effectively, it
# represents an identifier found within the source. It resolves to a symbol
# in Ruby.
#
# source://prism//lib/prism/reflection.rb#45
class Prism::Reflection::ConstantField < ::Prism::Reflection::Field; end
# A constant list field represents a list of constant values on a node. It
# resolves to an array of symbols in Ruby.
#
# source://prism//lib/prism/reflection.rb#55
class Prism::Reflection::ConstantListField < ::Prism::Reflection::Field; end
# A field represents a single piece of data on a node. It is the base class
# for all other field types.
#
# source://prism//lib/prism/reflection.rb#16
class Prism::Reflection::Field
# Initializes the field with the given name.
#
# @return [Field] a new instance of Field
#
# source://prism//lib/prism/reflection.rb#21
sig { params(name: Symbol).void }
def initialize(name); end
# The name of the field.
#
# source://prism//lib/prism/reflection.rb#18
sig { returns(Symbol) }
def name; end
end
# A flags field represents a bitset of flags on a node. It resolves to an
# integer in Ruby. Note that the flags cannot be accessed directly on the
# node because the integer is kept private. Instead, the various flags in
# the bitset should be accessed through their query methods.
#
# source://prism//lib/prism/reflection.rb#92
class Prism::Reflection::FlagsField < ::Prism::Reflection::Field
# Initializes the flags field with the given name and flags.
#
# @return [FlagsField] a new instance of FlagsField
#
# source://prism//lib/prism/reflection.rb#97
sig { params(name: Symbol, flags: T::Array[Symbol]).void }
def initialize(name, flags); end
# The names of the flags in the bitset.
#
# source://prism//lib/prism/reflection.rb#94
sig { returns(T::Array[Symbol]) }
def flags; end
end
# A float field represents a double-precision floating point value. It is
# used exclusively to represent the value of a floating point literal. It
# resolves to a Float in Ruby.
#
# source://prism//lib/prism/reflection.rb#85
class Prism::Reflection::FloatField < ::Prism::Reflection::Field; end
# An integer field represents an integer value. It is used to represent the
# value of an integer literal, the depth of local variables, and the number
# of a numbered reference. It resolves to an Integer in Ruby.
#
# source://prism//lib/prism/reflection.rb#79
class Prism::Reflection::IntegerField < ::Prism::Reflection::Field; end
# A location field represents the location of some part of the node in the
# source code. For example, the location of a keyword or an operator. It
# resolves to a Prism::Location in Ruby.
#
# source://prism//lib/prism/reflection.rb#67
class Prism::Reflection::LocationField < ::Prism::Reflection::Field; end
# A node field represents a single child node in the syntax tree. It
# resolves to a Prism::Node in Ruby.
#
# source://prism//lib/prism/reflection.rb#28
class Prism::Reflection::NodeField < ::Prism::Reflection::Field; end
# A node list field represents a list of child nodes in the syntax tree. It
# resolves to an array of Prism::Node instances in Ruby.
#
# source://prism//lib/prism/reflection.rb#39
class Prism::Reflection::NodeListField < ::Prism::Reflection::Field; end
# An optional constant field represents a constant value on a node that may
# or may not be present. It resolves to either a symbol or nil in Ruby.
#
# source://prism//lib/prism/reflection.rb#50
class Prism::Reflection::OptionalConstantField < ::Prism::Reflection::Field; end
# An optional location field represents the location of some part of the
# node in the source code that may or may not be present. It resolves to
# either a Prism::Location or nil in Ruby.
#
# source://prism//lib/prism/reflection.rb#73
class Prism::Reflection::OptionalLocationField < ::Prism::Reflection::Field; end
# An optional node field represents a single child node in the syntax tree
# that may or may not be present. It resolves to either a Prism::Node or nil
# in Ruby.
#
# source://prism//lib/prism/reflection.rb#34
class Prism::Reflection::OptionalNodeField < ::Prism::Reflection::Field; end
# A string field represents a string value on a node. It almost always
# represents the unescaped value of a string-like literal. It resolves to a
# string in Ruby.
#
# source://prism//lib/prism/reflection.rb#61
class Prism::Reflection::StringField < ::Prism::Reflection::Field; end
# Flags for regular expression and match last line nodes.
#
# source://prism//lib/prism/node.rb#19214
module Prism::RegularExpressionFlags; end
# n - forces the ASCII-8BIT encoding
#
# source://prism//lib/prism/node.rb#19231
Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer)
# e - forces the EUC-JP encoding
#
# source://prism//lib/prism/node.rb#19228
Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer)
# x - ignores whitespace and allows comments in regular expressions
#
# source://prism//lib/prism/node.rb#19219
Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to binary
#
# source://prism//lib/prism/node.rb#19243
Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to US-ASCII
#
# source://prism//lib/prism/node.rb#19246
Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to UTF-8
#
# source://prism//lib/prism/node.rb#19240
Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
# i - ignores the case of characters when matching
#
# source://prism//lib/prism/node.rb#19216
Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer)
# m - allows $ to match the end of lines within strings
#
# source://prism//lib/prism/node.rb#19222
Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer)
# o - only interpolates values into the regular expression once
#
# source://prism//lib/prism/node.rb#19225
Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer)
# u - forces the UTF-8 encoding
#
# source://prism//lib/prism/node.rb#19237
Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer)
# s - forces the Windows-31J encoding
#
# source://prism//lib/prism/node.rb#19234
Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer)
# Represents a regular expression literal with no interpolation.
#
# /foo/i
# ^^^^^^
#
# source://prism//lib/prism/node.rb#15731
class Prism::RegularExpressionNode < ::Prism::Node
include ::Prism::RegularExpressionOptions
# def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
#
# @return [RegularExpressionNode] a new instance of RegularExpressionNode
#
# source://prism//lib/prism/node.rb#15733
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#15909
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15744
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def ascii_8bit?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15830
sig { returns(T::Boolean) }
def ascii_8bit?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15749
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#15870
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#15795
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15759
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15754
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def content: () -> String
#
# source://prism//lib/prism/node.rb#15865
sig { returns(String) }
def content; end
# attr_reader content_loc: Location
#
# source://prism//lib/prism/node.rb#15788
sig { returns(Prism::Location) }
def content_loc; end
# def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> RegularExpressionNode
#
# source://prism//lib/prism/node.rb#15764
sig do
params(
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).returns(Prism::RegularExpressionNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15749
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
#
# source://prism//lib/prism/node.rb#15772
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def euc_jp?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15825
sig { returns(T::Boolean) }
def euc_jp?; end
# def extended?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15810
sig { returns(T::Boolean) }
def extended?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15850
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_us_ascii_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15855
sig { returns(T::Boolean) }
def forced_us_ascii_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15845
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def ignore_case?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15805
sig { returns(T::Boolean) }
def ignore_case?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15875
sig { override.returns(String) }
def inspect; end
# def multi_line?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15815
sig { returns(T::Boolean) }
def multi_line?; end
# def once?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15820
sig { returns(T::Boolean) }
def once?; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#15860
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#15781
sig { returns(Prism::Location) }
def opening_loc; end
sig { returns(Integer) }
def options; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15893
sig { override.returns(Symbol) }
def type; end
# attr_reader unescaped: String
#
# source://prism//lib/prism/node.rb#15802
sig { returns(String) }
def unescaped; end
# def utf_8?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15840
sig { returns(T::Boolean) }
def utf_8?; end
# def windows_31j?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15835
sig { returns(T::Boolean) }
def windows_31j?; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#15777
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#15903
def type; end
end
end
# source://prism//lib/prism/node_ext.rb#20
module Prism::RegularExpressionOptions
# Returns a numeric value that represents the flags that were used to create
# the regular expression.
#
# source://prism//lib/prism/node_ext.rb#23
def options; end
end
# Represents a required keyword parameter to a method, block, or lambda definition.
#
# def a(b: )
# ^^
# end
#
# source://prism//lib/prism/node.rb#15924
class Prism::RequiredKeywordParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol name, Location name_loc, Location location) -> void
#
# @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode
#
# source://prism//lib/prism/node.rb#15926
sig do
params(
source: Prism::Source,
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16021
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#15935
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15940
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#15950
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#15945
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?location: Location) -> RequiredKeywordParameterNode
#
# source://prism//lib/prism/node.rb#15955
sig do
params(
flags: Integer,
name: Symbol,
name_loc: Prism::Location,
location: Prism::Location
).returns(Prism::RequiredKeywordParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#15940
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#15963
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#15987
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#15972
sig { returns(Symbol) }
def name; end
# attr_reader name_loc: Location
#
# source://prism//lib/prism/node.rb#15975
sig { returns(Prism::Location) }
def name_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#15982
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16005
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#15968
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16015
def type; end
end
end
# Represents a required parameter to a method, block, or lambda definition.
#
# def a(b)
# ^
# end
#
# source://prism//lib/prism/node.rb#16034
class Prism::RequiredParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol name, Location location) -> void
#
# @return [RequiredParameterNode] a new instance of RequiredParameterNode
#
# source://prism//lib/prism/node.rb#16036
sig { params(source: Prism::Source, flags: Integer, name: Symbol, location: Prism::Location).void }
def initialize(source, flags, name, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16123
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16044
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16049
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16059
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16054
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> RequiredParameterNode
#
# source://prism//lib/prism/node.rb#16064
sig { params(flags: Integer, name: Symbol, location: Prism::Location).returns(Prism::RequiredParameterNode) }
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16049
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
#
# source://prism//lib/prism/node.rb#16072
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16089
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol
#
# source://prism//lib/prism/node.rb#16081
sig { returns(Symbol) }
def name; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16084
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16107
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#16077
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16117
def type; end
end
end
# Represents an expression modified with a rescue.
#
# foo rescue nil
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#16134
class Prism::RescueModifierNode < ::Prism::Node
# def initialize: (Prism::node expression, Location keyword_loc, Prism::node rescue_expression, Location location) -> void
#
# @return [RescueModifierNode] a new instance of RescueModifierNode
#
# source://prism//lib/prism/node.rb#16136
sig do
params(
source: Prism::Source,
expression: Prism::Node,
keyword_loc: Prism::Location,
rescue_expression: Prism::Node,
location: Prism::Location
).void
end
def initialize(source, expression, keyword_loc, rescue_expression, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16230
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16145
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16150
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16160
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16155
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node, ?location: Location) -> RescueModifierNode
#
# source://prism//lib/prism/node.rb#16165
sig do
params(
expression: Prism::Node,
keyword_loc: Prism::Location,
rescue_expression: Prism::Node,
location: Prism::Location
).returns(Prism::RescueModifierNode)
end
def copy(expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16150
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node, location: Location }
#
# source://prism//lib/prism/node.rb#16173
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader expression: Prism::node
#
# source://prism//lib/prism/node.rb#16178
sig { returns(Prism::Node) }
def expression; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16196
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#16191
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#16181
sig { returns(Prism::Location) }
def keyword_loc; end
# source://prism//lib/prism/parse_result/newlines.rb#115
def newline!(lines); end
# attr_reader rescue_expression: Prism::node
#
# source://prism//lib/prism/node.rb#16188
sig { returns(Prism::Node) }
def rescue_expression; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16214
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16224
def type; end
end
end
# Represents a rescue statement.
#
# begin
# rescue Foo, *splat, Bar => ex
# foo
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# end
#
# `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
#
# source://prism//lib/prism/node.rb#16247
class Prism::RescueNode < ::Prism::Node
# def initialize: (Location keyword_loc, Array[Prism::node] exceptions, Location? operator_loc, Prism::node? reference, StatementsNode? statements, RescueNode? consequent, Location location) -> void
#
# @return [RescueNode] a new instance of RescueNode
#
# source://prism//lib/prism/node.rb#16249
sig do
params(
source: Prism::Source,
keyword_loc: Prism::Location,
exceptions: T::Array[Prism::Node],
operator_loc: T.nilable(Prism::Location),
reference: T.nilable(Prism::Node),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::RescueNode),
location: Prism::Location
).void
end
def initialize(source, keyword_loc, exceptions, operator_loc, reference, statements, consequent, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16375
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16261
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16266
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16281
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16271
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader consequent: RescueNode?
#
# source://prism//lib/prism/node.rb#16328
sig { returns(T.nilable(Prism::RescueNode)) }
def consequent; end
# def copy: (?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: Prism::node?, ?statements: StatementsNode?, ?consequent: RescueNode?, ?location: Location) -> RescueNode
#
# source://prism//lib/prism/node.rb#16286
sig do
params(
keyword_loc: Prism::Location,
exceptions: T::Array[Prism::Node],
operator_loc: T.nilable(Prism::Location),
reference: T.nilable(Prism::Node),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::RescueNode),
location: Prism::Location
).returns(Prism::RescueNode)
end
def copy(keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16266
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: Prism::node?, statements: StatementsNode?, consequent: RescueNode?, location: Location }
#
# source://prism//lib/prism/node.rb#16294
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader exceptions: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#16306
sig { returns(T::Array[Prism::Node]) }
def exceptions; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16341
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#16331
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#16299
sig { returns(Prism::Location) }
def keyword_loc; end
# def operator: () -> String?
#
# source://prism//lib/prism/node.rb#16336
sig { returns(T.nilable(String)) }
def operator; end
# attr_reader operator_loc: Location?
#
# source://prism//lib/prism/node.rb#16309
sig { returns(T.nilable(Prism::Location)) }
def operator_loc; end
# attr_reader reference: Prism::node?
#
# source://prism//lib/prism/node.rb#16322
sig { returns(T.nilable(Prism::Node)) }
def reference; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#16325
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16359
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16369
def type; end
end
end
# Represents a rest parameter to a method, block, or lambda definition.
#
# def a(*b)
# ^^
# end
#
# source://prism//lib/prism/node.rb#16392
class Prism::RestParameterNode < ::Prism::Node
# def initialize: (Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
#
# @return [RestParameterNode] a new instance of RestParameterNode
#
# source://prism//lib/prism/node.rb#16394
sig do
params(
source: Prism::Source,
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, flags, name, name_loc, operator_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16508
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16404
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16409
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16419
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16414
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> RestParameterNode
#
# source://prism//lib/prism/node.rb#16424
sig do
params(
flags: Integer,
name: T.nilable(Symbol),
name_loc: T.nilable(Prism::Location),
operator_loc: Prism::Location,
location: Prism::Location
).returns(Prism::RestParameterNode)
end
def copy(flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16409
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#16432
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16474
sig { override.returns(String) }
def inspect; end
# attr_reader name: Symbol?
#
# source://prism//lib/prism/node.rb#16441
sig { returns(T.nilable(Symbol)) }
def name; end
# attr_reader name_loc: Location?
#
# source://prism//lib/prism/node.rb#16444
sig { returns(T.nilable(Prism::Location)) }
def name_loc; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#16469
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#16457
sig { returns(Prism::Location) }
def operator_loc; end
# def repeated_parameter?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16464
sig { returns(T::Boolean) }
def repeated_parameter?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16492
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#16437
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16502
def type; end
end
end
# This represents the result of a call to ::parse or ::parse_file. It contains
# the requested structure, any comments that were encounters, and any errors
# that were encountered.
#
# source://prism//lib/prism/parse_result.rb#521
class Prism::Result
# Create a new result object with the given values.
#
# @return [Result] a new instance of Result
#
# source://prism//lib/prism/parse_result.rb#543
sig do
params(
comments: T::Array[Prism::Comment],
magic_comments: T::Array[Prism::MagicComment],
data_loc: T.nilable(Prism::Location),
errors: T::Array[Prism::ParseError],
warnings: T::Array[Prism::ParseWarning],
source: Prism::Source
).void
end
def initialize(comments, magic_comments, data_loc, errors, warnings, source); end
# The list of comments that were encountered during parsing.
#
# source://prism//lib/prism/parse_result.rb#523
sig { returns(T::Array[Prism::Comment]) }
def comments; end
# An optional location that represents the location of the __END__ marker
# and the rest of the content of the file. This content is loaded into the
# DATA constant when the file being parsed is the main file being executed.
#
# source://prism//lib/prism/parse_result.rb#531
sig { returns(T.nilable(Prism::Location)) }
def data_loc; end
# Implement the hash pattern matching interface for Result.
#
# source://prism//lib/prism/parse_result.rb#553
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# Returns the encoding of the source code that was parsed.
#
# source://prism//lib/prism/parse_result.rb#558
sig { returns(Encoding) }
def encoding; end
# The list of errors that were generated during parsing.
#
# source://prism//lib/prism/parse_result.rb#534
sig { returns(T::Array[Prism::ParseError]) }
def errors; end
# Returns true if there were errors during parsing and false if there were
# not.
#
# @return [Boolean]
#
# source://prism//lib/prism/parse_result.rb#570
sig { returns(T::Boolean) }
def failure?; end
# The list of magic comments that were encountered during parsing.
#
# source://prism//lib/prism/parse_result.rb#526
sig { returns(T::Array[Prism::MagicComment]) }
def magic_comments; end
# A Source instance that represents the source code that was parsed.
#
# source://prism//lib/prism/parse_result.rb#540
sig { returns(Prism::Source) }
def source; end
# Returns true if there were no errors during parsing and false if there
# were.
#
# @return [Boolean]
#
# source://prism//lib/prism/parse_result.rb#564
sig { returns(T::Boolean) }
def success?; end
# The list of warnings that were generated during parsing.
#
# source://prism//lib/prism/parse_result.rb#537
sig { returns(T::Array[Prism::ParseWarning]) }
def warnings; end
end
# Represents the use of the `retry` keyword.
#
# retry
# ^^^^^
#
# source://prism//lib/prism/node.rb#16521
class Prism::RetryNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [RetryNode] a new instance of RetryNode
#
# source://prism//lib/prism/node.rb#16523
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16596
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16529
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16534
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16544
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16539
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> RetryNode
#
# source://prism//lib/prism/node.rb#16549
sig { params(location: Prism::Location).returns(Prism::RetryNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16534
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#16557
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16562
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16580
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16590
def type; end
end
end
# Represents the use of the `return` keyword.
#
# return 1
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#16605
class Prism::ReturnNode < ::Prism::Node
# def initialize: (Integer flags, Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
#
# @return [ReturnNode] a new instance of ReturnNode
#
# source://prism//lib/prism/node.rb#16607
sig do
params(
source: Prism::Source,
flags: Integer,
keyword_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
location: Prism::Location
).void
end
def initialize(source, flags, keyword_loc, arguments, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16709
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16616
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#16662
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16621
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16633
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16626
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?, ?location: Location) -> ReturnNode
#
# source://prism//lib/prism/node.rb#16638
sig do
params(
flags: Integer,
keyword_loc: Prism::Location,
arguments: T.nilable(Prism::ArgumentsNode),
location: Prism::Location
).returns(Prism::ReturnNode)
end
def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16621
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
#
# source://prism//lib/prism/node.rb#16646
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16675
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#16670
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#16655
sig { returns(Prism::Location) }
def keyword_loc; end
# def redundant?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16665
sig { returns(T::Boolean) }
def redundant?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16693
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#16651
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16703
def type; end
end
end
# Flags for return nodes.
#
# source://prism//lib/prism/node.rb#19250
module Prism::ReturnNodeFlags; end
# a return statement that is redundant because it is the last statement in a method
#
# source://prism//lib/prism/node.rb#19252
Prism::ReturnNodeFlags::REDUNDANT = T.let(T.unsafe(nil), Integer)
# Represents the `self` keyword.
#
# self
# ^^^^
#
# source://prism//lib/prism/node.rb#16721
class Prism::SelfNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [SelfNode] a new instance of SelfNode
#
# source://prism//lib/prism/node.rb#16723
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16796
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16729
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16734
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16744
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16739
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> SelfNode
#
# source://prism//lib/prism/node.rb#16749
sig { params(location: Prism::Location).returns(Prism::SelfNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16734
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#16757
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16762
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16780
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16790
def type; end
end
end
# A module responsible for deserializing parse results.
#
# source://prism//lib/prism/serialize.rb#14
module Prism::Serialize
class << self
# Deserialize the AST represented by the given string into a parse result.
#
# source://prism//lib/prism/serialize.rb#28
def load(input, serialized); end
# Deserialize the tokens represented by the given string into a parse
# result.
#
# source://prism//lib/prism/serialize.rb#40
def load_tokens(source, serialized); end
end
end
# source://prism//lib/prism/serialize.rb#44
class Prism::Serialize::Loader
# @return [Loader] a new instance of Loader
#
# source://prism//lib/prism/serialize.rb#80
def initialize(source, serialized); end
# Returns the value of attribute constant_pool.
#
# source://prism//lib/prism/serialize.rb#77
def constant_pool; end
# Returns the value of attribute constant_pool_offset.
#
# source://prism//lib/prism/serialize.rb#77
def constant_pool_offset; end
# Returns the value of attribute encoding.
#
# source://prism//lib/prism/serialize.rb#76
def encoding; end
# Returns the value of attribute input.
#
# source://prism//lib/prism/serialize.rb#76
def input; end
# Returns the value of attribute io.
#
# source://prism//lib/prism/serialize.rb#76
def io; end
# source://prism//lib/prism/serialize.rb#118
def load_comments; end
# source://prism//lib/prism/serialize.rb#104
def load_encoding; end
# source://prism//lib/prism/serialize.rb#95
def load_header; end
# source://prism//lib/prism/serialize.rb#114
def load_line_offsets; end
# source://prism//lib/prism/serialize.rb#438
def load_metadata; end
# source://prism//lib/prism/serialize.rb#472
def load_nodes; end
# source://prism//lib/prism/serialize.rb#486
def load_result; end
# source://prism//lib/prism/serialize.rb#110
def load_start_line; end
# source://prism//lib/prism/serialize.rb#447
def load_tokens; end
# source://prism//lib/prism/serialize.rb#460
def load_tokens_result; end
# Returns the value of attribute serialized.
#
# source://prism//lib/prism/serialize.rb#76
def serialized; end
# Returns the value of attribute source.
#
# source://prism//lib/prism/serialize.rb#77
def source; end
# Returns the value of attribute start_line.
#
# source://prism//lib/prism/serialize.rb#78
def start_line; end
private
# source://prism//lib/prism/serialize.rb#572
def load_constant(index); end
# source://prism//lib/prism/serialize.rb#525
def load_double; end
# source://prism//lib/prism/serialize.rb#540
def load_embedded_string; end
# source://prism//lib/prism/serialize.rb#602
def load_error_level; end
# source://prism//lib/prism/serialize.rb#514
def load_integer; end
# source://prism//lib/prism/serialize.rb#556
def load_location; end
# source://prism//lib/prism/serialize.rb#560
def load_location_object; end
# source://prism//lib/prism/serialize.rb#631
def load_node; end
# source://prism//lib/prism/serialize.rb#597
def load_optional_constant; end
# source://prism//lib/prism/serialize.rb#564
def load_optional_location; end
# source://prism//lib/prism/serialize.rb#568
def load_optional_location_object; end
# source://prism//lib/prism/serialize.rb#533
def load_optional_node; end
# source://prism//lib/prism/serialize.rb#593
def load_required_constant; end
# source://prism//lib/prism/serialize.rb#544
def load_string; end
# source://prism//lib/prism/serialize.rb#529
def load_uint32; end
# source://prism//lib/prism/serialize.rb#509
def load_varsint; end
# variable-length integer using https://en.wikipedia.org/wiki/LEB128
# This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
#
# source://prism//lib/prism/serialize.rb#495
def load_varuint; end
# source://prism//lib/prism/serialize.rb#617
def load_warning_level; end
end
# source://prism//lib/prism/serialize.rb#127
Prism::Serialize::Loader::DIAGNOSTIC_TYPES = T.let(T.unsafe(nil), Array)
# StringIO is synchronized and that adds a high overhead on TruffleRuby.
#
# source://prism//lib/prism/serialize.rb#72
Prism::Serialize::Loader::FastStringIO = StringIO
# The major version of prism that we are expecting to find in the serialized
# strings.
#
# source://prism//lib/prism/serialize.rb#17
Prism::Serialize::MAJOR_VERSION = T.let(T.unsafe(nil), Integer)
# The minor version of prism that we are expecting to find in the serialized
# strings.
#
# source://prism//lib/prism/serialize.rb#21
Prism::Serialize::MINOR_VERSION = T.let(T.unsafe(nil), Integer)
# The patch version of prism that we are expecting to find in the serialized
# strings.
#
# source://prism//lib/prism/serialize.rb#25
Prism::Serialize::PATCH_VERSION = T.let(T.unsafe(nil), Integer)
# The token types that can be indexed by their enum values.
#
# source://prism//lib/prism/serialize.rb#1863
Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array)
# This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
#
# C = { a: 1 }
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#16806
class Prism::ShareableConstantNode < ::Prism::Node
# def initialize: (Integer flags, ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode write, Location location) -> void
#
# @return [ShareableConstantNode] a new instance of ShareableConstantNode
#
# source://prism//lib/prism/node.rb#16808
sig do
params(
source: Prism::Source,
flags: Integer,
write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode),
location: Prism::Location
).void
end
def initialize(source, flags, write, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#16905
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16816
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16821
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16831
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16826
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, ?location: Location) -> ShareableConstantNode
#
# source://prism//lib/prism/node.rb#16836
sig do
params(
flags: Integer,
write: T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode),
location: Prism::Location
).returns(Prism::ShareableConstantNode)
end
def copy(flags: T.unsafe(nil), write: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16821
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, location: Location }
#
# source://prism//lib/prism/node.rb#16844
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def experimental_copy?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16866
sig { returns(T::Boolean) }
def experimental_copy?; end
# def experimental_everything?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16861
sig { returns(T::Boolean) }
def experimental_everything?; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#16871
sig { override.returns(String) }
def inspect; end
# def literal?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#16856
sig { returns(T::Boolean) }
def literal?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16889
sig { override.returns(Symbol) }
def type; end
# The constant write that should be modified with the shareability state.
#
# source://prism//lib/prism/node.rb#16853
sig do
returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode))
end
def write; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#16849
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#16899
def type; end
end
end
# Flags for shareable constant nodes.
#
# source://prism//lib/prism/node.rb#19256
module Prism::ShareableConstantNodeFlags; end
# constant writes that should be modified with shareable constant value experimental copy
#
# source://prism//lib/prism/node.rb#19264
Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer)
# constant writes that should be modified with shareable constant value experimental everything
#
# source://prism//lib/prism/node.rb#19261
Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer)
# constant writes that should be modified with shareable constant value literal
#
# source://prism//lib/prism/node.rb#19258
Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer)
# Represents a singleton class declaration involving the `class` keyword.
#
# class << self end
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#16916
class Prism::SingletonClassNode < ::Prism::Node
# def initialize: (Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Prism::node expression, Prism::node? body, Location end_keyword_loc, Location location) -> void
#
# @return [SingletonClassNode] a new instance of SingletonClassNode
#
# source://prism//lib/prism/node.rb#16918
sig do
params(
source: Prism::Source,
locals: T::Array[Symbol],
class_keyword_loc: Prism::Location,
operator_loc: Prism::Location,
expression: Prism::Node,
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17045
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#16930
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Prism::node?
#
# source://prism//lib/prism/node.rb#16986
sig { returns(T.nilable(Prism::Node)) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16935
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def class_keyword: () -> String
#
# source://prism//lib/prism/node.rb#16996
sig { returns(String) }
def class_keyword; end
# attr_reader class_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#16969
sig { returns(Prism::Location) }
def class_keyword_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#16948
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#16940
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?location: Location) -> SingletonClassNode
#
# source://prism//lib/prism/node.rb#16953
sig do
params(
locals: T::Array[Symbol],
class_keyword_loc: Prism::Location,
operator_loc: Prism::Location,
expression: Prism::Node,
body: T.nilable(Prism::Node),
end_keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::SingletonClassNode)
end
def copy(locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#16935
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: Prism::node?, end_keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#16961
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String
#
# source://prism//lib/prism/node.rb#17006
sig { returns(String) }
def end_keyword; end
# attr_reader end_keyword_loc: Location
#
# source://prism//lib/prism/node.rb#16989
sig { returns(Prism::Location) }
def end_keyword_loc; end
# attr_reader expression: Prism::node
#
# source://prism//lib/prism/node.rb#16983
sig { returns(Prism::Node) }
def expression; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17011
sig { override.returns(String) }
def inspect; end
# attr_reader locals: Array[Symbol]
#
# source://prism//lib/prism/node.rb#16966
sig { returns(T::Array[Symbol]) }
def locals; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#17001
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#16976
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17029
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17039
def type; end
end
end
# This represents a source of Ruby code that has been parsed. It is used in
# conjunction with locations to allow them to resolve line numbers and source
# ranges.
#
# source://prism//lib/prism/parse_result.rb#7
class Prism::Source
# Create a new source object with the given source code.
#
# @return [Source] a new instance of Source
#
# source://prism//lib/prism/parse_result.rb#26
sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void }
def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
# Return the column number in characters for the given byte offset.
#
# source://prism//lib/prism/parse_result.rb#78
sig { params(byte_offset: Integer).returns(Integer) }
def character_column(byte_offset); end
# Return the character offset for the given byte offset.
#
# source://prism//lib/prism/parse_result.rb#73
sig { params(byte_offset: Integer).returns(Integer) }
def character_offset(byte_offset); end
# Returns the column number in code units for the given encoding for the
# given byte offset.
#
# source://prism//lib/prism/parse_result.rb#95
sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
def code_units_column(byte_offset, encoding); end
# Returns the offset from the start of the file for the given byte offset
# counting in code units for the given encoding.
#
# This method is tested with UTF-8, UTF-16, and UTF-32. If there is the
# concept of code units that differs from the number of characters in other
# encodings, it is not captured here.
#
# source://prism//lib/prism/parse_result.rb#88
sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) }
def code_units_offset(byte_offset, encoding); end
# Return the column number for the given byte offset.
#
# source://prism//lib/prism/parse_result.rb#68
sig { params(byte_offset: Integer).returns(Integer) }
def column(byte_offset); end
# Returns the encoding of the source code, which is set by parameters to the
# parser or by the encoding magic comment.
#
# source://prism//lib/prism/parse_result.rb#34
sig { returns(Encoding) }
def encoding; end
# Binary search through the offsets to find the line number for the given
# byte offset.
#
# source://prism//lib/prism/parse_result.rb#51
sig { params(byte_offset: Integer).returns(Integer) }
def line(byte_offset); end
# Returns the byte offset of the end of the line corresponding to the given
# byte offset.
#
# source://prism//lib/prism/parse_result.rb#63
def line_end(byte_offset); end
# Return the byte offset of the start of the line corresponding to the given
# byte offset.
#
# source://prism//lib/prism/parse_result.rb#57
sig { params(byte_offset: Integer).returns(Integer) }
def line_start(byte_offset); end
# Returns the lines of the source code as an array of strings.
#
# source://prism//lib/prism/parse_result.rb#39
sig { returns(T::Array[String]) }
def lines; end
# The list of newline byte offsets in the source code.
#
# source://prism//lib/prism/parse_result.rb#23
sig { returns(T::Array[Integer]) }
def offsets; end
# Perform a byteslice on the source code using the given byte offset and
# byte length.
#
# source://prism//lib/prism/parse_result.rb#45
sig { params(byte_offset: Integer, length: Integer).returns(String) }
def slice(byte_offset, length); end
# The source code that this source object represents.
#
# source://prism//lib/prism/parse_result.rb#17
sig { returns(String) }
def source; end
# The line number where this source starts.
#
# source://prism//lib/prism/parse_result.rb#20
sig { returns(Integer) }
def start_line; end
private
# Binary search through the offsets to find the line number for the given
# byte offset.
#
# source://prism//lib/prism/parse_result.rb#103
def find_line(byte_offset); end
class << self
# Create a new source object with the given source code. This method should
# be used instead of `new` and it will return either a `Source` or a
# specialized and more performant `ASCIISource` if no multibyte characters
# are present in the source code.
#
# source://prism//lib/prism/parse_result.rb#12
def for(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end
end
end
# Represents the use of the `__ENCODING__` keyword.
#
# __ENCODING__
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#17061
class Prism::SourceEncodingNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [SourceEncodingNode] a new instance of SourceEncodingNode
#
# source://prism//lib/prism/node.rb#17063
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17136
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17069
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17074
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17084
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17079
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> SourceEncodingNode
#
# source://prism//lib/prism/node.rb#17089
sig { params(location: Prism::Location).returns(Prism::SourceEncodingNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17074
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#17097
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17102
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17120
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17130
def type; end
end
end
# Represents the use of the `__FILE__` keyword.
#
# __FILE__
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#17145
class Prism::SourceFileNode < ::Prism::Node
# def initialize: (Integer flags, String filepath, Location location) -> void
#
# @return [SourceFileNode] a new instance of SourceFileNode
#
# source://prism//lib/prism/node.rb#17147
sig { params(source: Prism::Source, flags: Integer, filepath: String, location: Prism::Location).void }
def initialize(source, flags, filepath, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17249
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17155
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17160
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17170
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17165
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?filepath: String, ?location: Location) -> SourceFileNode
#
# source://prism//lib/prism/node.rb#17175
sig { params(flags: Integer, filepath: String, location: Prism::Location).returns(Prism::SourceFileNode) }
def copy(flags: T.unsafe(nil), filepath: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17160
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, filepath: String, location: Location }
#
# source://prism//lib/prism/node.rb#17183
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
#
# source://prism//lib/prism/node.rb#17192
sig { returns(String) }
def filepath; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17200
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17195
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def frozen?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17205
sig { returns(T::Boolean) }
def frozen?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17215
sig { override.returns(String) }
def inspect; end
# def mutable?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17210
sig { returns(T::Boolean) }
def mutable?; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17233
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#17188
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17243
def type; end
end
end
# Represents the use of the `__LINE__` keyword.
#
# __LINE__
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#17260
class Prism::SourceLineNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [SourceLineNode] a new instance of SourceLineNode
#
# source://prism//lib/prism/node.rb#17262
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17335
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17268
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17273
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17283
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17278
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> SourceLineNode
#
# source://prism//lib/prism/node.rb#17288
sig { params(location: Prism::Location).returns(Prism::SourceLineNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17273
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#17296
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17301
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17319
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17329
def type; end
end
end
# Represents the use of the splat operator.
#
# [*a]
# ^^
#
# source://prism//lib/prism/node.rb#17344
class Prism::SplatNode < ::Prism::Node
# def initialize: (Location operator_loc, Prism::node? expression, Location location) -> void
#
# @return [SplatNode] a new instance of SplatNode
#
# source://prism//lib/prism/node.rb#17346
sig do
params(
source: Prism::Source,
operator_loc: Prism::Location,
expression: T.nilable(Prism::Node),
location: Prism::Location
).void
end
def initialize(source, operator_loc, expression, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17438
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17354
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17359
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17371
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17364
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?operator_loc: Location, ?expression: Prism::node?, ?location: Location) -> SplatNode
#
# source://prism//lib/prism/node.rb#17376
sig do
params(
operator_loc: Prism::Location,
expression: T.nilable(Prism::Node),
location: Prism::Location
).returns(Prism::SplatNode)
end
def copy(operator_loc: T.unsafe(nil), expression: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17359
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, expression: Prism::node?, location: Location }
#
# source://prism//lib/prism/node.rb#17384
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# attr_reader expression: Prism::node?
#
# source://prism//lib/prism/node.rb#17396
sig { returns(T.nilable(Prism::Node)) }
def expression; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17404
sig { override.returns(String) }
def inspect; end
# def operator: () -> String
#
# source://prism//lib/prism/node.rb#17399
sig { returns(String) }
def operator; end
# attr_reader operator_loc: Location
#
# source://prism//lib/prism/node.rb#17389
sig { returns(Prism::Location) }
def operator_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17422
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17432
def type; end
end
end
# Represents a set of statements contained within some scope.
#
# foo; bar; baz
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#17449
class Prism::StatementsNode < ::Prism::Node
# def initialize: (Array[Prism::node] body, Location location) -> void
#
# @return [StatementsNode] a new instance of StatementsNode
#
# source://prism//lib/prism/node.rb#17451
sig { params(source: Prism::Source, body: T::Array[Prism::Node], location: Prism::Location).void }
def initialize(source, body, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17528
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17458
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader body: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#17491
sig { returns(T::Array[Prism::Node]) }
def body; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17463
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17473
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17468
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?body: Array[Prism::node], ?location: Location) -> StatementsNode
#
# source://prism//lib/prism/node.rb#17478
sig { params(body: T::Array[Prism::Node], location: Prism::Location).returns(Prism::StatementsNode) }
def copy(body: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17463
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { body: Array[Prism::node], location: Location }
#
# source://prism//lib/prism/node.rb#17486
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17494
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17512
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17522
def type; end
end
end
# Flags for string nodes.
#
# source://prism//lib/prism/node.rb#19268
module Prism::StringFlags; end
# internal bytes forced the encoding to binary
#
# source://prism//lib/prism/node.rb#19273
Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to UTF-8
#
# source://prism//lib/prism/node.rb#19270
Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
# source://prism//lib/prism/node.rb#19276
Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer)
# source://prism//lib/prism/node.rb#19279
Prism::StringFlags::MUTABLE = T.let(T.unsafe(nil), Integer)
# Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
#
# "foo"
# ^^^^^
#
# %w[foo]
# ^^^
#
# "foo #{bar} baz"
# ^^^^ ^^^^
#
# source://prism//lib/prism/node.rb#17545
class Prism::StringNode < ::Prism::Node
include ::Prism::HeredocQuery
# def initialize: (Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped, Location location) -> void
#
# @return [StringNode] a new instance of StringNode
#
# source://prism//lib/prism/node.rb#17547
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: T.nilable(Prism::Location),
content_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
unescaped: String,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17700
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17558
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17563
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#17661
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#17615
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17573
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17568
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def content: () -> String
#
# source://prism//lib/prism/node.rb#17656
sig { returns(String) }
def content; end
# attr_reader content_loc: Location
#
# source://prism//lib/prism/node.rb#17608
sig { returns(Prism::Location) }
def content_loc; end
# def copy: (?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> StringNode
#
# source://prism//lib/prism/node.rb#17578
sig do
params(
flags: Integer,
opening_loc: T.nilable(Prism::Location),
content_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
unescaped: String,
location: Prism::Location
).returns(Prism::StringNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17563
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location }
#
# source://prism//lib/prism/node.rb#17586
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17636
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17631
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def frozen?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17641
sig { returns(T::Boolean) }
def frozen?; end
sig { returns(T::Boolean) }
def heredoc?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17666
sig { override.returns(String) }
def inspect; end
# def mutable?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17646
sig { returns(T::Boolean) }
def mutable?; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#17651
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#17595
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# Occasionally it's helpful to treat a string as if it were interpolated so
# that there's a consistent interface for working with strings.
#
# source://prism//lib/prism/node_ext.rb#69
sig { returns(Prism::InterpolatedStringNode) }
def to_interpolated; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17684
sig { override.returns(Symbol) }
def type; end
# attr_reader unescaped: String
#
# source://prism//lib/prism/node.rb#17628
sig { returns(String) }
def unescaped; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#17591
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17694
def type; end
end
end
# Represents the use of the `super` keyword with parentheses or arguments.
#
# super()
# ^^^^^^^
#
# super foo, bar
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#17717
class Prism::SuperNode < ::Prism::Node
# def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Prism::node? block, Location location) -> void
#
# @return [SuperNode] a new instance of SuperNode
#
# source://prism//lib/prism/node.rb#17719
sig do
params(
source: Prism::Source,
keyword_loc: Prism::Location,
lparen_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
rparen_loc: T.nilable(Prism::Location),
block: T.nilable(Prism::Node),
location: Prism::Location
).void
end
def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, block, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#17854
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17730
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#17786
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# attr_reader block: Prism::node?
#
# source://prism//lib/prism/node.rb#17802
sig { returns(T.nilable(Prism::Node)) }
def block; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17735
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17748
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17740
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: Prism::node?, ?location: Location) -> SuperNode
#
# source://prism//lib/prism/node.rb#17753
sig do
params(
keyword_loc: Prism::Location,
lparen_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
rparen_loc: T.nilable(Prism::Location),
block: T.nilable(Prism::Node),
location: Prism::Location
).returns(Prism::SuperNode)
end
def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17735
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Prism::node?, location: Location }
#
# source://prism//lib/prism/node.rb#17761
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17820
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#17805
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#17766
sig { returns(Prism::Location) }
def keyword_loc; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#17810
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#17773
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#17815
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#17789
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17838
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#17848
def type; end
end
end
# Flags for symbol nodes.
#
# source://prism//lib/prism/node.rb#19283
module Prism::SymbolFlags; end
# internal bytes forced the encoding to binary
#
# source://prism//lib/prism/node.rb#19288
Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to US-ASCII
#
# source://prism//lib/prism/node.rb#19291
Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer)
# internal bytes forced the encoding to UTF-8
#
# source://prism//lib/prism/node.rb#19285
Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer)
# Represents a symbol literal or a symbol contained within a `%i` list.
#
# :foo
# ^^^^
#
# %i[foo]
# ^^^
#
# source://prism//lib/prism/node.rb#17871
class Prism::SymbolNode < ::Prism::Node
# def initialize: (Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped, Location location) -> void
#
# @return [SymbolNode] a new instance of SymbolNode
#
# source://prism//lib/prism/node.rb#17873
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: T.nilable(Prism::Location),
value_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
unescaped: String,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, value_loc, closing_loc, unescaped, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18027
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#17884
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17889
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#17988
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#17947
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#17899
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#17894
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> SymbolNode
#
# source://prism//lib/prism/node.rb#17904
sig do
params(
flags: Integer,
opening_loc: T.nilable(Prism::Location),
value_loc: T.nilable(Prism::Location),
closing_loc: T.nilable(Prism::Location),
unescaped: String,
location: Prism::Location
).returns(Prism::SymbolNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#17889
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location }
#
# source://prism//lib/prism/node.rb#17912
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17968
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_us_ascii_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17973
sig { returns(T::Boolean) }
def forced_us_ascii_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#17963
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#17993
sig { override.returns(String) }
def inspect; end
# def opening: () -> String?
#
# source://prism//lib/prism/node.rb#17978
sig { returns(T.nilable(String)) }
def opening; end
# attr_reader opening_loc: Location?
#
# source://prism//lib/prism/node.rb#17921
sig { returns(T.nilable(Prism::Location)) }
def opening_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18011
sig { override.returns(Symbol) }
def type; end
# attr_reader unescaped: String
#
# source://prism//lib/prism/node.rb#17960
sig { returns(String) }
def unescaped; end
# def value: () -> String?
#
# source://prism//lib/prism/node.rb#17983
sig { returns(T.nilable(String)) }
def value; end
# attr_reader value_loc: Location?
#
# source://prism//lib/prism/node.rb#17934
sig { returns(T.nilable(Prism::Location)) }
def value_loc; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#17917
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18021
def type; end
end
end
# This represents a token from the Ruby source.
#
# source://prism//lib/prism/parse_result.rb#645
class Prism::Token
# Create a new token object with the given type, value, and location.
#
# @return [Token] a new instance of Token
#
# source://prism//lib/prism/parse_result.rb#657
sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void }
def initialize(source, type, value, location); end
# Returns true if the given other token is equal to this token.
#
# source://prism//lib/prism/parse_result.rb#692
sig { params(other: T.untyped).returns(T::Boolean) }
def ==(other); end
# Implement the hash pattern matching interface for Token.
#
# source://prism//lib/prism/parse_result.rb#665
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# A Location object representing the location of this token in the source.
#
# source://prism//lib/prism/parse_result.rb#670
sig { returns(Prism::Location) }
def location; end
# Implement the pretty print interface for Token.
#
# source://prism//lib/prism/parse_result.rb#677
sig { params(q: T.untyped).void }
def pretty_print(q); end
# The type of token that this token is.
#
# source://prism//lib/prism/parse_result.rb#651
sig { returns(Symbol) }
def type; end
# A byteslice of the source that this token represents.
#
# source://prism//lib/prism/parse_result.rb#654
sig { returns(String) }
def value; end
private
# The Source object that represents the source this token came from.
#
# source://prism//lib/prism/parse_result.rb#647
sig { returns(Prism::Source) }
def source; end
end
# This module is responsible for converting the prism syntax tree into other
# syntax trees.
#
# source://prism//lib/prism/translation.rb#6
module Prism::Translation; end
# This class is the entry-point for converting a prism syntax tree into the
# whitequark/parser gem's syntax tree. It inherits from the base parser for
# the parser gem, and overrides the parse* methods to parse with prism and
# then translate.
#
# source://prism//lib/prism/translation/parser.rb#16
class Prism::Translation::Parser < ::Parser::Base
# The default encoding for Ruby files is UTF-8.
#
# source://prism//lib/prism/translation/parser.rb#41
def default_encoding; end
# Parses a source buffer and returns the AST.
#
# source://prism//lib/prism/translation/parser.rb#49
def parse(source_buffer); end
# Parses a source buffer and returns the AST and the source code comments.
#
# source://prism//lib/prism/translation/parser.rb#62
def parse_with_comments(source_buffer); end
# Parses a source buffer and returns the AST, the source code comments,
# and the tokens emitted by the lexer.
#
# source://prism//lib/prism/translation/parser.rb#79
def tokenize(source_buffer, recover = T.unsafe(nil)); end
# Since prism resolves num params for us, we don't need to support this
# kind of logic here.
#
# source://prism//lib/prism/translation/parser.rb#105
def try_declare_numparam(node); end
# source://prism//lib/prism/translation/parser.rb#36
sig { overridable.returns(Integer) }
def version; end
# source://prism//lib/prism/translation/parser.rb#45
def yyerror; end
private
# Build the parser gem AST from the prism AST.
#
# source://prism//lib/prism/translation/parser.rb#263
def build_ast(program, offset_cache); end
# Build the parser gem comments from the prism comments.
#
# source://prism//lib/prism/translation/parser.rb#268
def build_comments(comments, offset_cache); end
# Prism deals with offsets in bytes, while the parser gem deals with
# offsets in characters. We need to handle this conversion in order to
# build the parser gem AST.
#
# If the bytesize of the source is the same as the length, then we can
# just use the offset directly. Otherwise, we build an array where the
# index is the byte offset and the value is the character offset.
#
# source://prism//lib/prism/translation/parser.rb#246
def build_offset_cache(source); end
# Build a range from a prism location.
#
# source://prism//lib/prism/translation/parser.rb#280
def build_range(location, offset_cache); end
# Build the parser gem tokens from the prism tokens.
#
# source://prism//lib/prism/translation/parser.rb#275
def build_tokens(tokens, offset_cache); end
# Converts the version format handled by Parser to the format handled by Prism.
#
# source://prism//lib/prism/translation/parser.rb#289
def convert_for_prism(version); end
# Build a diagnostic from the given prism parse error.
#
# source://prism//lib/prism/translation/parser.rb#124
def error_diagnostic(error, offset_cache); end
# If there was a error generated during the parse, then raise an
# appropriate syntax error. Otherwise return the result.
#
# source://prism//lib/prism/translation/parser.rb#224
def unwrap(result, offset_cache); end
# This is a hook to allow consumers to disable some errors if they don't
# want them to block creating the syntax tree.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/parser.rb#113
def valid_error?(error); end
# This is a hook to allow consumers to disable some warnings if they don't
# want them to block creating the syntax tree.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/parser.rb#119
def valid_warning?(warning); end
# Build a diagnostic from the given prism parse warning.
#
# source://prism//lib/prism/translation/parser.rb#197
def warning_diagnostic(warning, offset_cache); end
end
# This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
#
# source://prism//lib/prism/translation/parser33.rb#6
class Prism::Translation::Parser33 < ::Prism::Translation::Parser
# source://prism//lib/prism/translation/parser33.rb#7
sig { override.returns(Integer) }
def version; end
end
# This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
#
# source://prism//lib/prism/translation/parser34.rb#6
class Prism::Translation::Parser34 < ::Prism::Translation::Parser
# source://prism//lib/prism/translation/parser34.rb#7
sig { override.returns(Integer) }
def version; end
end
# A visitor that knows how to convert a prism syntax tree into the
# whitequark/parser gem's syntax tree.
#
# source://prism//lib/prism/translation/parser/compiler.rb#8
class Prism::Translation::Parser::Compiler < ::Prism::Compiler
# Initialize a new compiler with the given parser, offset cache, and
# options.
#
# @return [Compiler] a new instance of Compiler
#
# source://prism//lib/prism/translation/parser/compiler.rb#39
def initialize(parser, offset_cache, forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
# The Parser::Builders::Default instance that is being used to build the
# AST.
#
# source://prism//lib/prism/translation/parser/compiler.rb#18
def builder; end
# The types of values that can be forwarded in the current scope.
#
# source://prism//lib/prism/translation/parser/compiler.rb#29
def forwarding; end
# Whether or not the current node is in a destructure.
#
# source://prism//lib/prism/translation/parser/compiler.rb#32
def in_destructure; end
# Whether or not the current node is in a pattern.
#
# source://prism//lib/prism/translation/parser/compiler.rb#35
def in_pattern; end
# The offset cache that is used to map between byte and character
# offsets in the file.
#
# source://prism//lib/prism/translation/parser/compiler.rb#26
def offset_cache; end
# The Parser::Base instance that is being used to build the AST.
#
# source://prism//lib/prism/translation/parser/compiler.rb#14
def parser; end
# The Parser::Source::Buffer instance that is holding a reference to the
# source code.
#
# source://prism//lib/prism/translation/parser/compiler.rb#22
def source_buffer; end
# alias $foo $bar
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#58
def visit_alias_global_variable_node(node); end
# alias foo bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#52
def visit_alias_method_node(node); end
# foo => bar | baz
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#64
def visit_alternation_pattern_node(node); end
# a and b
# ^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#70
def visit_and_node(node); end
# foo(bar)
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#105
def visit_arguments_node(node); end
# []
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#76
def visit_array_node(node); end
# foo => [bar]
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#82
def visit_array_pattern_node(node); end
# { a: 1 }
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#111
def visit_assoc_node(node); end
# def foo(**); bar(**); end
# ^^
#
# { **foo }
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#160
def visit_assoc_splat_node(node); end
# $+
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#172
def visit_back_reference_read_node(node); end
# begin end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#178
def visit_begin_node(node); end
# foo(&bar)
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#216
def visit_block_argument_node(node); end
# foo { |; bar| }
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#222
def visit_block_local_variable_node(node); end
# A block on a keyword or method call.
#
# @raise [CompilationError]
#
# source://prism//lib/prism/translation/parser/compiler.rb#227
def visit_block_node(node); end
# def foo(&bar); end
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#233
def visit_block_parameter_node(node); end
# A block's parameters.
#
# source://prism//lib/prism/translation/parser/compiler.rb#238
def visit_block_parameters_node(node); end
# break
# ^^^^^
#
# break foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#247
def visit_break_node(node); end
# foo.bar &&= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#352
def visit_call_and_write_node(node); end
# foo
# ^^^
#
# foo.bar
# ^^^^^^^
#
# foo.bar() {}
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#259
def visit_call_node(node); end
# foo.bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#333
def visit_call_operator_write_node(node); end
# foo.bar ||= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#371
def visit_call_or_write_node(node); end
# foo.bar, = 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#390
def visit_call_target_node(node); end
# foo => bar => baz
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#402
def visit_capture_pattern_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#421
def visit_case_match_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#408
def visit_case_node(node); end
# class Foo; end
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#434
def visit_class_node(node); end
# @@foo &&= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#473
def visit_class_variable_and_write_node(node); end
# @@foo += bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#463
def visit_class_variable_operator_write_node(node); end
# @@foo ||= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#483
def visit_class_variable_or_write_node(node); end
# @@foo
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#447
def visit_class_variable_read_node(node); end
# @@foo, = bar
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#493
def visit_class_variable_target_node(node); end
# @@foo = 1
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#453
def visit_class_variable_write_node(node); end
# Foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#524
def visit_constant_and_write_node(node); end
# Foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#514
def visit_constant_operator_write_node(node); end
# Foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#534
def visit_constant_or_write_node(node); end
# Foo::Bar &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#590
def visit_constant_path_and_write_node(node); end
# Foo::Bar
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#550
def visit_constant_path_node(node); end
# Foo::Bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#580
def visit_constant_path_operator_write_node(node); end
# Foo::Bar ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#600
def visit_constant_path_or_write_node(node); end
# Foo::Bar, = baz
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#610
def visit_constant_path_target_node(node); end
# Foo::Bar = 1
# ^^^^^^^^^^^^
#
# Foo::Foo, Bar::Bar = 1
# ^^^^^^^^ ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#570
def visit_constant_path_write_node(node); end
# Foo
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#499
def visit_constant_read_node(node); end
# Foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#544
def visit_constant_target_node(node); end
# Foo = 1
# ^^^^^^^
#
# Foo, Bar = 1
# ^^^ ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#508
def visit_constant_write_node(node); end
# def foo; end
# ^^^^^^^^^^^^
#
# def self.foo; end
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#619
def visit_def_node(node); end
# defined? a
# ^^^^^^^^^^
#
# defined?(a)
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#666
def visit_defined_node(node); end
# if foo then bar else baz end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#678
def visit_else_node(node); end
# "foo #{bar}"
# ^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#684
def visit_embedded_statements_node(node); end
# "foo #@bar"
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#694
def visit_embedded_variable_node(node); end
# begin; foo; ensure; bar; end
# ^^^^^^^^^^^^
#
# @raise [CompilationError]
#
# source://prism//lib/prism/translation/parser/compiler.rb#700
def visit_ensure_node(node); end
# false
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#706
def visit_false_node(node); end
# foo => [*, bar, *]
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#712
def visit_find_pattern_node(node); end
# 0..5
# ^^^^
# if foo .. bar; end
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1475
def visit_flip_flop_node(node); end
# 1.0
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#724
def visit_float_node(node); end
# for foo in bar do end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#730
def visit_for_node(node); end
# def foo(...); bar(...); end
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#748
def visit_forwarding_arguments_node(node); end
# def foo(...); end
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#754
def visit_forwarding_parameter_node(node); end
# super
# ^^^^^
#
# super {}
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#763
def visit_forwarding_super_node(node); end
# $foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#801
def visit_global_variable_and_write_node(node); end
# $foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#791
def visit_global_variable_operator_write_node(node); end
# $foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#811
def visit_global_variable_or_write_node(node); end
# $foo
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#775
def visit_global_variable_read_node(node); end
# $foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#821
def visit_global_variable_target_node(node); end
# $foo = 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#781
def visit_global_variable_write_node(node); end
# {}
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#827
def visit_hash_node(node); end
# foo => {}
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#837
def visit_hash_pattern_node(node); end
# if foo then bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar if foo
# ^^^^^^^^^^
#
# foo ? bar : baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#855
def visit_if_node(node); end
# 1i
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#897
def visit_imaginary_node(node); end
# { foo: }
# ^^^^
#
# @raise [CompilationError]
#
# source://prism//lib/prism/translation/parser/compiler.rb#903
def visit_implicit_node(node); end
# foo { |bar,| }
# ^
#
# @raise [CompilationError]
#
# source://prism//lib/prism/translation/parser/compiler.rb#909
def visit_implicit_rest_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#915
def visit_in_node(node); end
# foo[bar] &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#959
def visit_index_and_write_node(node); end
# foo[bar] += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#941
def visit_index_operator_write_node(node); end
# foo[bar] ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#977
def visit_index_or_write_node(node); end
# foo[bar], = 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#995
def visit_index_target_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1032
def visit_instance_variable_and_write_node(node); end
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1022
def visit_instance_variable_operator_write_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1042
def visit_instance_variable_or_write_node(node); end
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1006
def visit_instance_variable_read_node(node); end
# @foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1052
def visit_instance_variable_target_node(node); end
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1012
def visit_instance_variable_write_node(node); end
# 1
# ^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1058
def visit_integer_node(node); end
# /foo #{bar}/
# ^^^^^^^^^^^^
# if /foo #{bar}/ then end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1064
def visit_interpolated_match_last_line_node(node); end
# /foo #{bar}/
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1064
def visit_interpolated_regular_expression_node(node); end
# "foo #{bar}"
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1079
def visit_interpolated_string_node(node); end
# :"foo #{bar}"
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1113
def visit_interpolated_symbol_node(node); end
# `foo #{bar}`
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1123
def visit_interpolated_x_string_node(node); end
# -> { it }
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1137
def visit_it_local_variable_read_node(node); end
# -> { it }
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1143
def visit_it_parameters_node(node); end
# foo(bar: baz)
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1149
def visit_keyword_hash_node(node); end
# def foo(**bar); end
# ^^^^^
#
# def foo(**); end
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1158
def visit_keyword_rest_parameter_node(node); end
# -> {}
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1167
def visit_lambda_node(node); end
# foo &&= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1219
def visit_local_variable_and_write_node(node); end
# foo += bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1209
def visit_local_variable_operator_write_node(node); end
# foo ||= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1229
def visit_local_variable_or_write_node(node); end
# foo
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1193
def visit_local_variable_read_node(node); end
# foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1239
def visit_local_variable_target_node(node); end
# foo = 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1199
def visit_local_variable_write_node(node); end
# /foo/
# ^^^^^
# if /foo/ then end
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1509
def visit_match_last_line_node(node); end
# foo in bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1249
def visit_match_predicate_node(node); end
# foo => bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1259
def visit_match_required_node(node); end
# /(?<foo>foo)/ =~ bar
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1269
def visit_match_write_node(node); end
# A node that is missing from the syntax tree. This is only used in the
# case of a syntax error. The parser gem doesn't have such a concept, so
# we invent our own here.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1280
def visit_missing_node(node); end
# module Foo; end
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1286
def visit_module_node(node); end
# foo, bar = baz
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1297
def visit_multi_target_node(node); end
# foo, bar = baz
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1307
def visit_multi_write_node(node); end
# next
# ^^^^
#
# next foo
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1330
def visit_next_node(node); end
# nil
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1342
def visit_nil_node(node); end
# def foo(**nil); end
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1348
def visit_no_keywords_parameter_node(node); end
# -> { _1 + _2 }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1358
def visit_numbered_parameters_node(node); end
# $1
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1364
def visit_numbered_reference_read_node(node); end
# def foo(bar: baz); end
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1370
def visit_optional_keyword_parameter_node(node); end
# def foo(bar = 1); end
# ^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1376
def visit_optional_parameter_node(node); end
# a or b
# ^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1382
def visit_or_node(node); end
# def foo(bar, *baz); end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1388
def visit_parameters_node(node); end
# ()
# ^^
#
# (1)
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1427
def visit_parentheses_node(node); end
# foo => ^(bar)
# ^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1437
def visit_pinned_expression_node(node); end
# foo = 1 and bar => ^foo
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1444
def visit_pinned_variable_node(node); end
# END {}
#
# source://prism//lib/prism/translation/parser/compiler.rb#1449
def visit_post_execution_node(node); end
# BEGIN {}
#
# source://prism//lib/prism/translation/parser/compiler.rb#1459
def visit_pre_execution_node(node); end
# The top-level program node.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1469
def visit_program_node(node); end
# 0..5
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1475
def visit_range_node(node); end
# 1r
# ^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1497
def visit_rational_node(node); end
# redo
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1503
def visit_redo_node(node); end
# /foo/
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1509
def visit_regular_expression_node(node); end
# def foo(bar:); end
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1535
def visit_required_keyword_parameter_node(node); end
# def foo(bar); end
# ^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1541
def visit_required_parameter_node(node); end
# foo rescue bar
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1547
def visit_rescue_modifier_node(node); end
# begin; rescue; end
# ^^^^^^^
#
# @raise [CompilationError]
#
# source://prism//lib/prism/translation/parser/compiler.rb#1565
def visit_rescue_node(node); end
# def foo(*bar); end
# ^^^^
#
# def foo(*); end
# ^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1574
def visit_rest_parameter_node(node); end
# retry
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1580
def visit_retry_node(node); end
# return
# ^^^^^^
#
# return 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1589
def visit_return_node(node); end
# self
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1601
def visit_self_node(node); end
# A shareable constant.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1606
def visit_shareable_constant_node(node); end
# class << self; end
# ^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1612
def visit_singleton_class_node(node); end
# __ENCODING__
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1624
def visit_source_encoding_node(node); end
# __FILE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1630
def visit_source_file_node(node); end
# __LINE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1636
def visit_source_line_node(node); end
# foo(*bar)
# ^^^^
#
# def foo((bar, *baz)); end
# ^^^^
#
# def foo(*); bar(*); end
# ^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1648
def visit_splat_node(node); end
# A list of statements.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1661
def visit_statements_node(node); end
# "foo"
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1667
def visit_string_node(node); end
# super(foo)
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1709
def visit_super_node(node); end
# :foo
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1732
def visit_symbol_node(node); end
# true
# ^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1764
def visit_true_node(node); end
# undef foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1770
def visit_undef_node(node); end
# unless foo; bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar unless foo
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1779
def visit_unless_node(node); end
# until foo; bar end
# ^^^^^^^^^^^^^^^^^^
#
# bar until foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1809
def visit_until_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1831
def visit_when_node(node); end
# while foo; bar end
# ^^^^^^^^^^^^^^^^^^
#
# bar while foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1849
def visit_while_node(node); end
# `foo`
# ^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1871
def visit_x_string_node(node); end
# yield
# ^^^^^
#
# yield 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/parser/compiler.rb#1902
def visit_yield_node(node); end
private
# The parser gem automatically converts \r\n to \n, meaning our offsets
# need to be adjusted to always subtract 1 from the length.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2045
def chomped_bytesize(line); end
# Initialize a new compiler with the given option overrides, used to
# visit a subtree with the given options.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1916
def copy_compiler(forwarding: T.unsafe(nil), in_destructure: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
# When *, **, &, or ... are used as an argument in a method call, we
# check if they were allowed by the current context. To determine that
# we build this lookup table.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1923
def find_forwarding(node); end
# Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1936
def multi_target_elements(node); end
# Negate the value of a numeric node. This is a special case where you
# have a negative sign on one line and then a number on the next line.
# In normal Ruby, this will always be a method call. The parser gem,
# however, marks this as a numeric literal. We have to massage the tree
# here to get it into the correct form.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1948
def numeric_negate(message_loc, receiver); end
# Blocks can have a special set of parameters that automatically expand
# when given arrays if they have a single required parameter and no
# other parameters.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/parser/compiler.rb#1962
def procarg0?(parameters); end
# Constructs a new source range from the given start and end offsets.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1979
def srange(location); end
# Constructs a new source range by finding the given tokens between the
# given start offset and end offset. If the needle is not found, it
# returns nil. Importantly it does not search past newlines or comments.
#
# Note that end_offset is allowed to be nil, in which case this will
# search until the end of the string.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1994
def srange_find(start_offset, end_offset, tokens); end
# Constructs a new source range from the given start and end offsets.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1984
def srange_offsets(start_offset, end_offset); end
# Transform a location into a token that the parser gem expects.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2004
def token(location); end
# Visit a block node on a call.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2009
def visit_block(call, block); end
# Visit a heredoc that can be either a string or an xstring.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2051
def visit_heredoc(node); end
# Visit a numeric node and account for the optional sign.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2123
def visit_numeric(node, value); end
# Within the given block, track that we're within a pattern.
#
# source://prism//lib/prism/translation/parser/compiler.rb#2135
def within_pattern; end
end
# Raised when the tree is malformed or there is a bug in the compiler.
#
# source://prism//lib/prism/translation/parser/compiler.rb#10
class Prism::Translation::Parser::Compiler::CompilationError < ::StandardError; end
# Locations in the parser gem AST are generated using this class. We
# store a reference to its constant to make it slightly faster to look
# up.
#
# source://prism//lib/prism/translation/parser/compiler.rb#1976
Prism::Translation::Parser::Compiler::Range = Parser::Source::Range
# source://prism//lib/prism/translation/parser.rb#17
Prism::Translation::Parser::Diagnostic = Parser::Diagnostic
# Accepts a list of prism tokens and converts them into the expected
# format for the parser gem.
#
# source://prism//lib/prism/translation/parser/lexer.rb#8
class Prism::Translation::Parser::Lexer
# Initialize the lexer with the given source buffer, prism tokens, and
# offset cache.
#
# @return [Lexer] a new instance of Lexer
#
# source://prism//lib/prism/translation/parser/lexer.rb#204
def initialize(source_buffer, lexed, offset_cache); end
# An array of tuples that contain prism tokens and their associated lex
# state when they were lexed.
#
# source://prism//lib/prism/translation/parser/lexer.rb#197
def lexed; end
# A hash that maps offsets in bytes to offsets in characters.
#
# source://prism//lib/prism/translation/parser/lexer.rb#200
def offset_cache; end
# The Parser::Source::Buffer that the tokens were lexed from.
#
# source://prism//lib/prism/translation/parser/lexer.rb#193
def source_buffer; end
# Convert the prism tokens into the expected format for the parser gem.
#
# source://prism//lib/prism/translation/parser/lexer.rb#214
def to_a; end
private
# Parse a complex from the string representation.
#
# source://prism//lib/prism/translation/parser/lexer.rb#387
def parse_complex(value); end
# Parse a float from the string representation.
#
# source://prism//lib/prism/translation/parser/lexer.rb#380
def parse_float(value); end
# Parse an integer from the string representation.
#
# source://prism//lib/prism/translation/parser/lexer.rb#373
def parse_integer(value); end
# Parse a rational from the string representation.
#
# source://prism//lib/prism/translation/parser/lexer.rb#402
def parse_rational(value); end
end
# These constants represent flags in our lex state. We really, really
# don't want to be using them and we really, really don't want to be
# exposing them as part of our public API. Unfortunately, we don't have
# another way of matching the exact tokens that the parser gem expects
# without them. We should find another way to do this, but in the
# meantime we'll hide them from the documentation and mark them as
# private constants.
#
# source://prism//lib/prism/translation/parser/lexer.rb#187
Prism::Translation::Parser::Lexer::EXPR_BEG = T.let(T.unsafe(nil), Integer)
# source://prism//lib/prism/translation/parser/lexer.rb#188
Prism::Translation::Parser::Lexer::EXPR_LABEL = T.let(T.unsafe(nil), Integer)
# source://prism//lib/prism/translation/parser/lexer.rb#210
Prism::Translation::Parser::Lexer::Range = Parser::Source::Range
# The direct translating of types between the two lexers.
#
# source://prism//lib/prism/translation/parser/lexer.rb#10
Prism::Translation::Parser::Lexer::TYPES = T.let(T.unsafe(nil), Hash)
# The parser gem has a list of diagnostics with a hard-coded set of error
# messages. We create our own diagnostic class in order to set our own
# error messages.
#
# source://prism//lib/prism/translation/parser.rb#23
class Prism::Translation::Parser::PrismDiagnostic < ::Parser::Diagnostic
# Initialize a new diagnostic with the given message and location.
#
# @return [PrismDiagnostic] a new instance of PrismDiagnostic
#
# source://prism//lib/prism/translation/parser.rb#28
def initialize(message, level, reason, location); end
# This is the cached message coming from prism.
#
# source://prism//lib/prism/translation/parser.rb#25
def message; end
end
# source://prism//lib/prism/translation/parser.rb#34
Prism::Translation::Parser::Racc_debug_parser = T.let(T.unsafe(nil), FalseClass)
# This class provides a compatibility layer between prism and Ripper. It
# functions by parsing the entire tree first and then walking it and
# executing each of the Ripper callbacks as it goes. To use this class, you
# treat `Prism::Translation::Ripper` effectively as you would treat the
# `Ripper` class.
#
# Note that this class will serve the most common use cases, but Ripper's
# API is extensive and undocumented. It relies on reporting the state of the
# parser at any given time. We do our best to replicate that here, but
# because it is a different architecture it is not possible to perfectly
# replicate the behavior of Ripper.
#
# The main known difference is that we may omit dispatching some events in
# some cases. This impacts the following events:
#
# - on_assign_error
# - on_comma
# - on_ignored_nl
# - on_ignored_sp
# - on_kw
# - on_label_end
# - on_lbrace
# - on_lbracket
# - on_lparen
# - on_nl
# - on_op
# - on_operator_ambiguous
# - on_rbrace
# - on_rbracket
# - on_rparen
# - on_semicolon
# - on_sp
# - on_symbeg
# - on_tstring_beg
# - on_tstring_end
#
# source://prism//lib/prism/translation/ripper.rb#43
class Prism::Translation::Ripper < ::Prism::Compiler
# Create a new Translation::Ripper object with the given source.
#
# @return [Ripper] a new instance of Ripper
#
# source://prism//lib/prism/translation/ripper.rb#444
def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
# The current column number of the parser.
#
# source://prism//lib/prism/translation/ripper.rb#441
def column; end
# True if the parser encountered an error during parsing.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/ripper.rb#457
sig { returns(T::Boolean) }
def error?; end
# The filename of the source being parsed.
#
# source://prism//lib/prism/translation/ripper.rb#435
def filename; end
# The current line number of the parser.
#
# source://prism//lib/prism/translation/ripper.rb#438
def lineno; end
# Parse the source and return the result.
#
# source://prism//lib/prism/translation/ripper.rb#462
sig { returns(T.untyped) }
def parse; end
# The source that is being parsed.
#
# source://prism//lib/prism/translation/ripper.rb#432
def source; end
# alias $foo $bar
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#561
def visit_alias_global_variable_node(node); end
# alias foo bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#551
def visit_alias_method_node(node); end
# foo => bar | baz
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#585
def visit_alternation_pattern_node(node); end
# a and b
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#605
def visit_and_node(node); end
# foo(bar)
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#796
def visit_arguments_node(node); end
# []
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#615
def visit_array_node(node); end
# foo => [bar]
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#775
def visit_array_pattern_node(node); end
# { a: 1 }
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#803
def visit_assoc_node(node); end
# def foo(**); bar(**); end
# ^^
#
# { **foo }
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#816
def visit_assoc_splat_node(node); end
# $+
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#825
def visit_back_reference_read_node(node); end
# begin end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#832
def visit_begin_node(node); end
# foo(&bar)
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#896
def visit_block_argument_node(node); end
# foo { |; bar| }
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#902
def visit_block_local_variable_node(node); end
# Visit a BlockNode.
#
# source://prism//lib/prism/translation/ripper.rb#908
def visit_block_node(node); end
# def foo(&bar); end
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#944
def visit_block_parameter_node(node); end
# A block's parameters.
#
# source://prism//lib/prism/translation/ripper.rb#958
def visit_block_parameters_node(node); end
# break
# ^^^^^
#
# break foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#982
def visit_break_node(node); end
# foo.bar &&= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1194
def visit_call_and_write_node(node); end
# foo
# ^^^
#
# foo.bar
# ^^^^^^^
#
# foo.bar() {}
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1002
def visit_call_node(node); end
# foo.bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1172
def visit_call_operator_write_node(node); end
# foo.bar ||= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1216
def visit_call_or_write_node(node); end
# foo.bar, = 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1238
def visit_call_target_node(node); end
# foo => bar => baz
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1263
def visit_capture_pattern_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1286
def visit_case_match_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1273
def visit_case_node(node); end
# class Foo; end
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1299
def visit_class_node(node); end
# @@foo &&= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1352
def visit_class_variable_and_write_node(node); end
# @@foo += bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1338
def visit_class_variable_operator_write_node(node); end
# @@foo ||= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1366
def visit_class_variable_or_write_node(node); end
# @@foo
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1317
def visit_class_variable_read_node(node); end
# @@foo, = bar
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1380
def visit_class_variable_target_node(node); end
# @@foo = 1
# ^^^^^^^^^
#
# @@foo, @@bar = 1
# ^^^^^ ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1327
def visit_class_variable_write_node(node); end
# Foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1422
def visit_constant_and_write_node(node); end
# Foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1408
def visit_constant_operator_write_node(node); end
# Foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1436
def visit_constant_or_write_node(node); end
# Foo::Bar &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1523
def visit_constant_path_and_write_node(node); end
# Foo::Bar
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1457
def visit_constant_path_node(node); end
# Foo::Bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1509
def visit_constant_path_operator_write_node(node); end
# Foo::Bar ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1537
def visit_constant_path_or_write_node(node); end
# Foo::Bar, = baz
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1551
def visit_constant_path_target_node(node); end
# Foo::Bar = 1
# ^^^^^^^^^^^^
#
# Foo::Foo, Bar::Bar = 1
# ^^^^^^^^ ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1480
def visit_constant_path_write_node(node); end
# Foo
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1387
def visit_constant_read_node(node); end
# Foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1450
def visit_constant_target_node(node); end
# Foo = 1
# ^^^^^^^
#
# Foo, Bar = 1
# ^^^ ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1397
def visit_constant_write_node(node); end
# def foo; end
# ^^^^^^^^^^^^
#
# def self.foo; end
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1560
def visit_def_node(node); end
# defined? a
# ^^^^^^^^^^
#
# defined?(a)
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1607
def visit_defined_node(node); end
# if foo then bar else baz end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1614
def visit_else_node(node); end
# "foo #{bar}"
# ^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1630
def visit_embedded_statements_node(node); end
# "foo #@bar"
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1651
def visit_embedded_variable_node(node); end
# Visit an EnsureNode node.
#
# source://prism//lib/prism/translation/ripper.rb#1662
def visit_ensure_node(node); end
# false
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1680
def visit_false_node(node); end
# foo => [*, bar, *]
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1687
def visit_find_pattern_node(node); end
# if foo .. bar; end
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1712
def visit_flip_flop_node(node); end
# 1.0
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1726
def visit_float_node(node); end
# for foo in bar do end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1732
def visit_for_node(node); end
# def foo(...); bar(...); end
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1749
def visit_forwarding_arguments_node(node); end
# def foo(...); end
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#1756
def visit_forwarding_parameter_node(node); end
# super
# ^^^^^
#
# super {}
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1766
def visit_forwarding_super_node(node); end
# $foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1815
def visit_global_variable_and_write_node(node); end
# $foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1801
def visit_global_variable_operator_write_node(node); end
# $foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1829
def visit_global_variable_or_write_node(node); end
# $foo
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1780
def visit_global_variable_read_node(node); end
# $foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1843
def visit_global_variable_target_node(node); end
# $foo = 1
# ^^^^^^^^
#
# $foo, $bar = 1
# ^^^^ ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1790
def visit_global_variable_write_node(node); end
# {}
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#1850
def visit_hash_node(node); end
# foo => {}
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#1865
def visit_hash_pattern_node(node); end
# if foo then bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar if foo
# ^^^^^^^^^^
#
# foo ? bar : baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1907
def visit_if_node(node); end
# 1i
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#1943
def visit_imaginary_node(node); end
# { foo: }
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1949
def visit_implicit_node(node); end
# foo { |bar,| }
# ^
#
# source://prism//lib/prism/translation/ripper.rb#1954
def visit_implicit_rest_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1961
def visit_in_node(node); end
# foo[bar] &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1996
def visit_index_and_write_node(node); end
# foo[bar] += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#1979
def visit_index_operator_write_node(node); end
# foo[bar] ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2013
def visit_index_or_write_node(node); end
# foo[bar], = 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2030
def visit_index_target_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2072
def visit_instance_variable_and_write_node(node); end
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2058
def visit_instance_variable_operator_write_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2086
def visit_instance_variable_or_write_node(node); end
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2040
def visit_instance_variable_read_node(node); end
# @foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2100
def visit_instance_variable_target_node(node); end
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2047
def visit_instance_variable_write_node(node); end
# 1
# ^
#
# source://prism//lib/prism/translation/ripper.rb#2107
def visit_integer_node(node); end
# if /foo #{bar}/ then end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2113
def visit_interpolated_match_last_line_node(node); end
# /foo #{bar}/
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2132
def visit_interpolated_regular_expression_node(node); end
# "foo #{bar}"
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2151
def visit_interpolated_string_node(node); end
# :"foo #{bar}"
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2179
def visit_interpolated_symbol_node(node); end
# `foo #{bar}`
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2192
def visit_interpolated_x_string_node(node); end
# -> { it }
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#2222
def visit_it_local_variable_read_node(node); end
# -> { it }
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2229
def visit_it_parameters_node(node); end
# foo(bar: baz)
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2234
def visit_keyword_hash_node(node); end
# def foo(**bar); end
# ^^^^^
#
# def foo(**); end
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#2246
def visit_keyword_rest_parameter_node(node); end
# -> {}
#
# source://prism//lib/prism/translation/ripper.rb#2260
def visit_lambda_node(node); end
# foo &&= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2352
def visit_local_variable_and_write_node(node); end
# foo += bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2338
def visit_local_variable_operator_write_node(node); end
# foo ||= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2366
def visit_local_variable_or_write_node(node); end
# foo
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#2320
def visit_local_variable_read_node(node); end
# foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#2380
def visit_local_variable_target_node(node); end
# foo = 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2327
def visit_local_variable_write_node(node); end
# if /foo/ then end
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2387
def visit_match_last_line_node(node); end
# foo in bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2402
def visit_match_predicate_node(node); end
# foo => bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2411
def visit_match_required_node(node); end
# /(?<foo>foo)/ =~ bar
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2420
def visit_match_write_node(node); end
# A node that is missing from the syntax tree. This is only used in the
# case of a syntax error.
#
# source://prism//lib/prism/translation/ripper.rb#2426
def visit_missing_node(node); end
# module Foo; end
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2432
def visit_module_node(node); end
# (foo, bar), bar = qux
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2449
def visit_multi_target_node(node); end
# foo, bar = baz
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2503
def visit_multi_write_node(node); end
# next
# ^^^^
#
# next foo
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2523
def visit_next_node(node); end
# nil
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#2537
def visit_nil_node(node); end
# def foo(**nil); end
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2544
def visit_no_keywords_parameter_node(node); end
# -> { _1 + _2 }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2553
def visit_numbered_parameters_node(node); end
# $1
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#2558
def visit_numbered_reference_read_node(node); end
# def foo(bar: baz); end
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2565
def visit_optional_keyword_parameter_node(node); end
# def foo(bar = 1); end
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2575
def visit_optional_parameter_node(node); end
# a or b
# ^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2585
def visit_or_node(node); end
# def foo(bar, *baz); end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2595
def visit_parameters_node(node); end
# ()
# ^^
#
# (1)
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#2622
def visit_parentheses_node(node); end
# foo => ^(bar)
# ^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2636
def visit_pinned_expression_node(node); end
# foo = 1 and bar => ^foo
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2645
def visit_pinned_variable_node(node); end
# END {}
# ^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2651
def visit_post_execution_node(node); end
# BEGIN {}
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2666
def visit_pre_execution_node(node); end
# The top-level program node.
#
# source://prism//lib/prism/translation/ripper.rb#2680
def visit_program_node(node); end
# 0..5
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2691
def visit_range_node(node); end
# 1r
# ^^
#
# source://prism//lib/prism/translation/ripper.rb#2705
def visit_rational_node(node); end
# redo
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2711
def visit_redo_node(node); end
# /foo/
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2718
def visit_regular_expression_node(node); end
# def foo(bar:); end
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2740
def visit_required_keyword_parameter_node(node); end
# def foo(bar); end
# ^^^
#
# source://prism//lib/prism/translation/ripper.rb#2747
def visit_required_parameter_node(node); end
# foo rescue bar
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2754
def visit_rescue_modifier_node(node); end
# begin; rescue; end
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2764
def visit_rescue_node(node); end
# def foo(*bar); end
# ^^^^
#
# def foo(*); end
# ^
#
# source://prism//lib/prism/translation/ripper.rb#2822
def visit_rest_parameter_node(node); end
# retry
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2834
def visit_retry_node(node); end
# return
# ^^^^^^
#
# return 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2844
def visit_return_node(node); end
# self
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2858
def visit_self_node(node); end
# A shareable constant.
#
# source://prism//lib/prism/translation/ripper.rb#2864
def visit_shareable_constant_node(node); end
# class << self; end
# ^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2870
def visit_singleton_class_node(node); end
# __ENCODING__
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2880
def visit_source_encoding_node(node); end
# __FILE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2887
def visit_source_file_node(node); end
# __LINE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2894
def visit_source_line_node(node); end
# foo(*bar)
# ^^^^
#
# def foo((bar, *baz)); end
# ^^^^
#
# def foo(*); bar(*); end
# ^
#
# source://prism//lib/prism/translation/ripper.rb#2907
def visit_splat_node(node); end
# A list of statements.
#
# source://prism//lib/prism/translation/ripper.rb#2912
def visit_statements_node(node); end
# "foo"
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#2929
def visit_string_node(node); end
# super(foo)
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3061
def visit_super_node(node); end
# :foo
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3082
def visit_symbol_node(node); end
# true
# ^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3106
def visit_true_node(node); end
# undef foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3113
def visit_undef_node(node); end
# unless foo; bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar unless foo
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3125
def visit_unless_node(node); end
# until foo; bar end
# ^^^^^^^^^^^^^^^^^
#
# bar until foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3153
def visit_until_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3177
def visit_when_node(node); end
# while foo; bar end
# ^^^^^^^^^^^^^^^^^^
#
# bar while foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3198
def visit_while_node(node); end
# `foo`
# ^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3222
def visit_x_string_node(node); end
# yield
# ^^^^^
#
# yield 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/ripper.rb#3245
def visit_yield_node(node); end
private
# :stopdoc:
#
# source://prism//lib/prism/translation/ripper.rb#3389
def _dispatch_0; end
# source://prism//lib/prism/translation/ripper.rb#3390
def _dispatch_1(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def _dispatch_2(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3392
def _dispatch_3(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3393
def _dispatch_4(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3394
def _dispatch_5(_, _, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3395
def _dispatch_7(_, _, _, _, _, _, _); end
# This method is responsible for updating lineno and column information
# to reflect the current node.
#
# This method could be drastically improved with some caching on the start
# of every line, but for now it's good enough.
#
# source://prism//lib/prism/translation/ripper.rb#3379
def bounds(location); end
# Returns true if the given node is a command node.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/ripper.rb#1163
def command?(node); end
# This method is called when the parser found syntax error.
#
# source://prism//lib/prism/translation/ripper.rb#3417
def compile_error(msg); end
# This method is provided by the Ripper C extension. It is called when a
# string needs to be dedented because of a tilde heredoc. It is expected
# that it will modify the string in place and return the number of bytes
# that were removed.
#
# source://prism//lib/prism/translation/ripper.rb#3432
def dedent_string(string, width); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_BEGIN(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_CHAR(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_END(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on___end__(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_alias(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_alias_error(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_aref(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_aref_field(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_arg_ambiguous(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_arg_paren(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_args_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_args_add_block(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_args_add_star(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_args_forward; end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_args_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_array(_); end
# source://prism//lib/prism/translation/ripper.rb#3393
def on_aryptn(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_assign(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_assign_error(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_assoc_new(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_assoc_splat(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_assoclist_from_args(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_backref(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_backtick(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_bare_assoc_hash(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_begin(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_binary(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_block_var(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_blockarg(_); end
# source://prism//lib/prism/translation/ripper.rb#3393
def on_bodystmt(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_brace_block(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_break(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_call(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_case(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_class(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_class_name_error(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_comma(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_command(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3393
def on_command_call(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_comment(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_const(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_const_path_field(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_const_path_ref(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_const_ref(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_cvar(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_def(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_defined(_); end
# source://prism//lib/prism/translation/ripper.rb#3394
def on_defs(_, _, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_do_block(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_dot2(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_dot3(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_dyna_symbol(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_else(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_elsif(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embdoc(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embdoc_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embdoc_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embexpr_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embexpr_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_embvar(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_ensure(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_excessed_comma; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_fcall(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_field(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_float(_); end
# source://prism//lib/prism/translation/ripper.rb#3393
def on_fndptn(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_for(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_gvar(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_hash(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_heredoc_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_heredoc_dedent(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_heredoc_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_hshptn(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_ident(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_if(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_if_mod(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_ifop(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_ignored_nl(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_ignored_sp(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_imaginary(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_in(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_int(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_ivar(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_kw(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_kwrest_param(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_label(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_label_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_lambda(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_lbrace(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_lbracket(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_lparen(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_magic_comment(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_massign(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_method_add_arg(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_method_add_block(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_mlhs_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_mlhs_add_post(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_mlhs_add_star(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_mlhs_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_mlhs_paren(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_module(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_mrhs_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_mrhs_add_star(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_mrhs_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_mrhs_new_from_args(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_next(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_nl(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_nokw_param(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_op(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_opassign(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_operator_ambiguous(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_param_error(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3395
def on_params(_, _, _, _, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_paren(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_parse_error(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_period(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_program(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_qsymbols_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_qsymbols_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_qsymbols_new; end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_qwords_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_qwords_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_qwords_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_rational(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_rbrace(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_rbracket(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_redo; end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_regexp_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_regexp_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_regexp_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_regexp_literal(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_regexp_new; end
# source://prism//lib/prism/translation/ripper.rb#3393
def on_rescue(_, _, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_rescue_mod(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_rest_param(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_retry; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_return(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_return0; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_rparen(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_sclass(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_semicolon(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_sp(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_stmts_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_stmts_new; end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_string_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_string_concat(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_string_content; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_string_dvar(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_string_embexpr(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_string_literal(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_super(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_symbeg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_symbol(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_symbol_literal(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_symbols_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_symbols_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_symbols_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_tlambda(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_tlambeg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_top_const_field(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_top_const_ref(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_tstring_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_tstring_content(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_tstring_end(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_unary(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_undef(_); end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_unless(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_unless_mod(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_until(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_until_mod(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_var_alias(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_var_field(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_var_ref(_); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_vcall(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_void_stmt; end
# source://prism//lib/prism/translation/ripper.rb#3392
def on_when(_, _, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_while(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_while_mod(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_word_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_word_new; end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_words_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_words_beg(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_words_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_words_sep(_); end
# source://prism//lib/prism/translation/ripper.rb#3391
def on_xstring_add(_, _); end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_xstring_literal(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_xstring_new; end
# source://prism//lib/prism/translation/ripper.rb#3390
def on_yield(_); end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_yield0; end
# source://prism//lib/prism/translation/ripper.rb#3389
def on_zsuper; end
# Lazily initialize the parse result.
#
# source://prism//lib/prism/translation/ripper.rb#3271
def result; end
# Returns true if there is a comma between the two locations.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/ripper.rb#3284
def trailing_comma?(left, right); end
# Visit one side of an alias global variable node.
#
# source://prism//lib/prism/translation/ripper.rb#570
def visit_alias_global_variable_node_value(node); end
# Visit a list of elements, like the elements of an array or arguments.
#
# source://prism//lib/prism/translation/ripper.rb#756
def visit_arguments(elements); end
# Visit the clauses of a begin node to form an on_bodystmt call.
#
# source://prism//lib/prism/translation/ripper.rb#840
def visit_begin_node_clauses(location, node, allow_newline); end
# Visit the body of a structure that can have either a set of statements
# or statements wrapped in rescue/else/ensure.
#
# source://prism//lib/prism/translation/ripper.rb#875
def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end
# Visit the arguments and block of a call node and return the arguments
# and block as they should be used.
#
# source://prism//lib/prism/translation/ripper.rb#1136
def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end
# Visit a constant path that is part of a write node.
#
# source://prism//lib/prism/translation/ripper.rb#1489
def visit_constant_path_write_node_target(node); end
# Visit a destructured positional parameter node.
#
# source://prism//lib/prism/translation/ripper.rb#2609
def visit_destructured_parameter_node(node); end
# Visit a string that is expressed using a <<~ heredoc.
#
# source://prism//lib/prism/translation/ripper.rb#2980
def visit_heredoc_node(parts, base); end
# Ripper gives back the escaped string content but strips out the common
# leading whitespace. Prism gives back the unescaped string content and
# a location for the escaped string content. Unfortunately these don't
# work well together, so here we need to re-derive the common leading
# whitespace.
#
# source://prism//lib/prism/translation/ripper.rb#2955
def visit_heredoc_node_whitespace(parts); end
# Visit a heredoc node that is representing a string.
#
# source://prism//lib/prism/translation/ripper.rb#3026
def visit_heredoc_string_node(node); end
# Visit a heredoc node that is representing an xstring.
#
# source://prism//lib/prism/translation/ripper.rb#3043
def visit_heredoc_x_string_node(node); end
# Visit the targets of a multi-target node.
#
# source://prism//lib/prism/translation/ripper.rb#2462
def visit_multi_target_node_targets(lefts, rest, rights, skippable); end
# Visit a node that represents a number. We need to explicitly handle the
# unary - operator.
#
# source://prism//lib/prism/translation/ripper.rb#3323
def visit_number_node(node); end
# Visit a pattern within a pattern match. This is used to bypass the
# parenthesis node that can be used to wrap patterns.
#
# source://prism//lib/prism/translation/ripper.rb#595
def visit_pattern_node(node); end
# Visit the list of statements of a statements node. We support nil
# statements in the list. This would normally not be allowed by the
# structure of the prism parse tree, but we manually add them here so that
# we can mirror Ripper's void stmt.
#
# source://prism//lib/prism/translation/ripper.rb#2921
def visit_statements_node_body(body); end
# Visit an individual part of a string-like node.
#
# source://prism//lib/prism/translation/ripper.rb#2211
def visit_string_content(part); end
# Visit the string content of a particular node. This method is used to
# split into the various token types.
#
# source://prism//lib/prism/translation/ripper.rb#3296
def visit_token(token, allow_keywords = T.unsafe(nil)); end
# Dispatch a words_sep event that contains the space between the elements
# of list literals.
#
# source://prism//lib/prism/translation/ripper.rb#745
def visit_words_sep(opening_loc, previous, current); end
# Visit a node that represents a write value. This is used to handle the
# special case of an implicit array that is generated without brackets.
#
# source://prism//lib/prism/translation/ripper.rb#3341
def visit_write_value(node); end
# Returns true if there is a semicolon between the two locations.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/ripper.rb#3289
def void_stmt?(left, right, allow_newline); end
# This method is called when weak warning is produced by the parser.
# +fmt+ and +args+ is printf style.
#
# source://prism//lib/prism/translation/ripper.rb#3408
def warn(fmt, *args); end
# This method is called when strong warning is produced by the parser.
# +fmt+ and +args+ is printf style.
#
# source://prism//lib/prism/translation/ripper.rb#3413
def warning(fmt, *args); end
class << self
# Tokenizes the Ruby program and returns an array of an array,
# which is formatted like
# <code>[[lineno, column], type, token, state]</code>.
# The +filename+ argument is mostly ignored.
# By default, this method does not handle syntax errors in +src+,
# use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
#
# require "ripper"
# require "pp"
#
# pp Ripper.lex("def m(a) nil end")
# #=> [[[1, 0], :on_kw, "def", FNAME ],
# [[1, 3], :on_sp, " ", FNAME ],
# [[1, 4], :on_ident, "m", ENDFN ],
# [[1, 5], :on_lparen, "(", BEG|LABEL],
# [[1, 6], :on_ident, "a", ARG ],
# [[1, 7], :on_rparen, ")", ENDFN ],
# [[1, 8], :on_sp, " ", BEG ],
# [[1, 9], :on_kw, "nil", END ],
# [[1, 12], :on_sp, " ", END ],
# [[1, 13], :on_kw, "end", END ]]
#
# source://prism//lib/prism/translation/ripper.rb#72
def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
# Parses the given Ruby program read from +src+.
# +src+ must be a String or an IO or a object with a #gets method.
#
# source://prism//lib/prism/translation/ripper.rb#46
def parse(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end
# Parses +src+ and create S-exp tree.
# Returns more readable tree rather than Ripper.sexp_raw.
# This method is mainly for developer use.
# The +filename+ argument is mostly ignored.
# By default, this method does not handle syntax errors in +src+,
# returning +nil+ in such cases. Use the +raise_errors+ keyword
# to raise a SyntaxError for an error in +src+.
#
# require "ripper"
# require "pp"
#
# pp Ripper.sexp("def m(a) nil end")
# #=> [:program,
# [[:def,
# [:@ident, "m", [1, 4]],
# [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
# [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
#
# source://prism//lib/prism/translation/ripper.rb#381
def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
# Parses +src+ and create S-exp tree.
# This method is mainly for developer use.
# The +filename+ argument is mostly ignored.
# By default, this method does not handle syntax errors in +src+,
# returning +nil+ in such cases. Use the +raise_errors+ keyword
# to raise a SyntaxError for an error in +src+.
#
# require "ripper"
# require "pp"
#
# pp Ripper.sexp_raw("def m(a) nil end")
# #=> [:program,
# [:stmts_add,
# [:stmts_new],
# [:def,
# [:@ident, "m", [1, 4]],
# [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
# [:bodystmt,
# [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
# nil,
# nil,
# nil]]]]
#
# source://prism//lib/prism/translation/ripper.rb#416
def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end
end
end
# A list of all of the Ruby binary operators.
#
# source://prism//lib/prism/translation/ripper.rb#337
Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array)
# This array contains name of all ripper events.
#
# source://prism//lib/prism/translation/ripper.rb#289
Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array)
# A list of all of the Ruby keywords.
#
# source://prism//lib/prism/translation/ripper.rb#292
Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array)
# This array contains name of parser events.
#
# source://prism//lib/prism/translation/ripper.rb#283
Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array)
# This contains a table of all of the parser events and their
# corresponding arity.
#
# source://prism//lib/prism/translation/ripper.rb#84
Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
# This array contains name of scanner events.
#
# source://prism//lib/prism/translation/ripper.rb#286
Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array)
# This contains a table of all of the scanner events and their
# corresponding arity.
#
# source://prism//lib/prism/translation/ripper.rb#227
Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash)
# This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
# returns the arrays of [type, *children].
#
# source://prism//lib/prism/translation/ripper/sexp.rb#10
class Prism::Translation::Ripper::SexpBuilder < ::Prism::Translation::Ripper
# :stopdoc:
#
# source://prism//lib/prism/translation/ripper/sexp.rb#13
def error; end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_BEGIN(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_CHAR(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_END(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on___end__(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_alias(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_alias_error(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_aref(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_aref_field(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_arg_ambiguous(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_arg_paren(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_args_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_args_add_block(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_args_add_star(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_args_forward(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_args_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_array(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_aryptn(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_assign(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_assign_error(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_assoc_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_assoc_splat(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_assoclist_from_args(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_backref(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_backtick(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_bare_assoc_hash(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_begin(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_binary(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_block_var(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_blockarg(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_bodystmt(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_brace_block(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_break(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_call(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_case(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_class(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_class_name_error(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_comma(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_command(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_command_call(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_comment(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_const(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_const_path_field(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_const_path_ref(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_const_ref(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_cvar(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_def(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_defined(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_defs(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_do_block(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_dot2(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_dot3(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_dyna_symbol(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_else(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_elsif(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embdoc(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embdoc_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embdoc_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embexpr_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embexpr_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_embvar(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_ensure(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_excessed_comma(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_fcall(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_field(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_float(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_fndptn(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_for(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_gvar(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_hash(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_heredoc_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_heredoc_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_hshptn(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_ident(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_if(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_if_mod(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_ifop(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_ignored_nl(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_ignored_sp(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_imaginary(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_in(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_int(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_ivar(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_kw(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_kwrest_param(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_label(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_label_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_lambda(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_lbrace(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_lbracket(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_lparen(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_magic_comment(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_massign(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_method_add_arg(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_method_add_block(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mlhs_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mlhs_add_post(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mlhs_add_star(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mlhs_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mlhs_paren(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_module(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mrhs_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mrhs_add_star(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mrhs_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_mrhs_new_from_args(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_next(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_nl(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_nokw_param(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_op(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_opassign(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_operator_ambiguous(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_param_error(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_params(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_paren(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_period(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_program(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_qsymbols_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_qsymbols_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_qsymbols_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_qwords_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_qwords_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_qwords_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_rational(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_rbrace(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_rbracket(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_redo(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_regexp_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_regexp_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_regexp_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_regexp_literal(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_regexp_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_rescue(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_rescue_mod(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_rest_param(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_retry(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_return(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_return0(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_rparen(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_sclass(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_semicolon(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_sp(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_stmts_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_stmts_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_concat(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_content(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_dvar(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_embexpr(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_string_literal(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_super(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_symbeg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_symbol(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_symbol_literal(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_symbols_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_symbols_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_symbols_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_tlambda(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_tlambeg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_top_const_field(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_top_const_ref(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_tstring_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_tstring_content(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_tstring_end(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_unary(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_undef(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_unless(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_unless_mod(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_until(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_until_mod(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_var_alias(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_var_field(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_var_ref(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_vcall(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_void_stmt(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_when(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_while(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_while_mod(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_word_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_word_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_words_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_words_beg(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_words_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#55
def on_words_sep(tok); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_xstring_add(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_xstring_literal(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_xstring_new(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_yield(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_yield0(*args); end
# source://prism//lib/prism/translation/ripper/sexp.rb#47
def on_zsuper(*args); end
private
# source://prism//lib/prism/translation/ripper/sexp.rb#61
def compile_error(mesg); end
# source://prism//lib/prism/translation/ripper/sexp.rb#17
def dedent_element(e, width); end
# source://prism//lib/prism/translation/ripper/sexp.rb#61
def on_error(mesg); end
# source://prism//lib/prism/translation/ripper/sexp.rb#24
def on_heredoc_dedent(val, width); end
# source://prism//lib/prism/translation/ripper/sexp.rb#61
def on_parse_error(mesg); end
end
# This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
# returns the same values as ::Ripper::SexpBuilder except with a couple of
# niceties that flatten linked lists into arrays.
#
# source://prism//lib/prism/translation/ripper/sexp.rb#74
class Prism::Translation::Ripper::SexpBuilderPP < ::Prism::Translation::Ripper::SexpBuilder
private
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def _dispatch_event_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def _dispatch_event_push(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_args_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_args_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#79
def on_heredoc_dedent(val, width); end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_mlhs_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#109
def on_mlhs_add_post(list, post); end
# source://prism//lib/prism/translation/ripper/sexp.rb#105
def on_mlhs_add_star(list, star); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_mlhs_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#101
def on_mlhs_paren(list); end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_mrhs_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_mrhs_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_qsymbols_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_qsymbols_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_qwords_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_qwords_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_regexp_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_regexp_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_stmts_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_stmts_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_string_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_symbols_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_symbols_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_word_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_word_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_words_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_words_new; end
# source://prism//lib/prism/translation/ripper/sexp.rb#96
def on_xstring_add(list, item); end
# source://prism//lib/prism/translation/ripper/sexp.rb#92
def on_xstring_new; end
end
# This module is the entry-point for converting a prism syntax tree into the
# seattlerb/ruby_parser gem's syntax tree.
#
# source://prism//lib/prism/translation/ruby_parser.rb#14
class Prism::Translation::RubyParser
# Parse the given source and translate it into the seattlerb/ruby_parser
# gem's Sexp format.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1556
def parse(source, filepath = T.unsafe(nil)); end
# Parse the given file and translate it into the seattlerb/ruby_parser
# gem's Sexp format.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1562
def parse_file(filepath); end
private
# Translate the given parse result and filepath into the
# seattlerb/ruby_parser gem's Sexp format.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1584
def translate(result, filepath); end
class << self
# Parse the given source and translate it into the seattlerb/ruby_parser
# gem's Sexp format.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1569
def parse(source, filepath = T.unsafe(nil)); end
# Parse the given file and translate it into the seattlerb/ruby_parser
# gem's Sexp format.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1575
def parse_file(filepath); end
end
end
# A prism visitor that builds Sexp objects.
#
# source://prism//lib/prism/translation/ruby_parser.rb#16
class Prism::Translation::RubyParser::Compiler < ::Prism::Compiler
# Initialize a new compiler with the given file name.
#
# @return [Compiler] a new instance of Compiler
#
# source://prism//lib/prism/translation/ruby_parser.rb#31
def initialize(file, in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
# This is the name of the file that we are compiling. We set it on every
# Sexp object that is generated, and also use it to compile __FILE__
# nodes.
#
# source://prism//lib/prism/translation/ruby_parser.rb#20
def file; end
# Class variables will change their type based on if they are inside of
# a method definition or not, so we need to track that state.
#
# source://prism//lib/prism/translation/ruby_parser.rb#24
def in_def; end
# Some nodes will change their representation if they are inside of a
# pattern, so we need to track that state.
#
# source://prism//lib/prism/translation/ruby_parser.rb#28
def in_pattern; end
# alias $foo $bar
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#45
def visit_alias_global_variable_node(node); end
# alias foo bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#39
def visit_alias_method_node(node); end
# foo => bar | baz
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#51
def visit_alternation_pattern_node(node); end
# a and b
# ^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#57
def visit_and_node(node); end
# foo(bar)
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#96
def visit_arguments_node(node); end
# []
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#63
def visit_array_node(node); end
# foo => [bar]
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#73
def visit_array_pattern_node(node); end
# { a: 1 }
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#102
def visit_assoc_node(node); end
# def foo(**); bar(**); end
# ^^
#
# { **foo }
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#111
def visit_assoc_splat_node(node); end
# $+
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#121
def visit_back_reference_read_node(node); end
# begin end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#127
def visit_begin_node(node); end
# foo(&bar)
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#160
def visit_block_argument_node(node); end
# foo { |; bar| }
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#168
def visit_block_local_variable_node(node); end
# A block on a keyword or method call.
#
# source://prism//lib/prism/translation/ruby_parser.rb#173
def visit_block_node(node); end
# def foo(&bar); end
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#179
def visit_block_parameter_node(node); end
# A block's parameters.
#
# source://prism//lib/prism/translation/ruby_parser.rb#184
def visit_block_parameters_node(node); end
# break
# ^^^^^
#
# break foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#224
def visit_break_node(node); end
# foo.bar &&= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#287
def visit_call_and_write_node(node); end
# foo
# ^^^
#
# foo.bar
# ^^^^^^^
#
# foo.bar() {}
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#242
def visit_call_node(node); end
# foo.bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#277
def visit_call_operator_write_node(node); end
# foo.bar ||= baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#297
def visit_call_or_write_node(node); end
# foo.bar, = 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#320
def visit_call_target_node(node); end
# foo => bar => baz
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#326
def visit_capture_pattern_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#338
def visit_case_match_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#332
def visit_case_node(node); end
# class Foo; end
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#344
def visit_class_node(node); end
# @@foo &&= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#385
def visit_class_variable_and_write_node(node); end
# @@foo += bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#379
def visit_class_variable_operator_write_node(node); end
# @@foo ||= bar
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#391
def visit_class_variable_or_write_node(node); end
# @@foo
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#364
def visit_class_variable_read_node(node); end
# @@foo, = bar
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#397
def visit_class_variable_target_node(node); end
# @@foo = 1
# ^^^^^^^^^
#
# @@foo, @@bar = 1
# ^^^^^ ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#373
def visit_class_variable_write_node(node); end
# Foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#430
def visit_constant_and_write_node(node); end
# Foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#424
def visit_constant_operator_write_node(node); end
# Foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#436
def visit_constant_or_write_node(node); end
# Foo::Bar &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#473
def visit_constant_path_and_write_node(node); end
# Foo::Bar
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#448
def visit_constant_path_node(node); end
# Foo::Bar += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#467
def visit_constant_path_operator_write_node(node); end
# Foo::Bar ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#479
def visit_constant_path_or_write_node(node); end
# Foo::Bar, = baz
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#485
def visit_constant_path_target_node(node); end
# Foo::Bar = 1
# ^^^^^^^^^^^^
#
# Foo::Foo, Bar::Bar = 1
# ^^^^^^^^ ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#461
def visit_constant_path_write_node(node); end
# Foo
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#409
def visit_constant_read_node(node); end
# Foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#442
def visit_constant_target_node(node); end
# Foo = 1
# ^^^^^^^
#
# Foo, Bar = 1
# ^^^ ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#418
def visit_constant_write_node(node); end
# def foo; end
# ^^^^^^^^^^^^
#
# def self.foo; end
# ^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#501
def visit_def_node(node); end
# defined? a
# ^^^^^^^^^^
#
# defined?(a)
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#532
def visit_defined_node(node); end
# if foo then bar else baz end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#538
def visit_else_node(node); end
# "foo #{bar}"
# ^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#544
def visit_embedded_statements_node(node); end
# "foo #@bar"
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#552
def visit_embedded_variable_node(node); end
# begin; foo; ensure; bar; end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#558
def visit_ensure_node(node); end
# false
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#564
def visit_false_node(node); end
# foo => [*, bar, *]
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#570
def visit_find_pattern_node(node); end
# if foo .. bar; end
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#576
def visit_flip_flop_node(node); end
# 1.0
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#586
def visit_float_node(node); end
# for foo in bar do end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#592
def visit_for_node(node); end
# def foo(...); bar(...); end
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#598
def visit_forwarding_arguments_node(node); end
# def foo(...); end
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#604
def visit_forwarding_parameter_node(node); end
# super
# ^^^^^
#
# super {}
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#613
def visit_forwarding_super_node(node); end
# $foo &&= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#640
def visit_global_variable_and_write_node(node); end
# $foo += bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#634
def visit_global_variable_operator_write_node(node); end
# $foo ||= bar
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#646
def visit_global_variable_or_write_node(node); end
# $foo
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#619
def visit_global_variable_read_node(node); end
# $foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#652
def visit_global_variable_target_node(node); end
# $foo = 1
# ^^^^^^^^
#
# $foo, $bar = 1
# ^^^^ ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#628
def visit_global_variable_write_node(node); end
# {}
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#658
def visit_hash_node(node); end
# foo => {}
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#664
def visit_hash_pattern_node(node); end
# if foo then bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar if foo
# ^^^^^^^^^^
#
# foo ? bar : baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#685
def visit_if_node(node); end
# 1i
#
# source://prism//lib/prism/translation/ruby_parser.rb#690
def visit_imaginary_node(node); end
# { foo: }
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#696
def visit_implicit_node(node); end
# foo { |bar,| }
# ^
#
# source://prism//lib/prism/translation/ruby_parser.rb#701
def visit_implicit_rest_node(node); end
# case foo; in bar; end
# ^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#706
def visit_in_node(node); end
# foo[bar] &&= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#732
def visit_index_and_write_node(node); end
# foo[bar] += baz
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#719
def visit_index_operator_write_node(node); end
# foo[bar] ||= baz
# ^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#745
def visit_index_or_write_node(node); end
# foo[bar], = 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#758
def visit_index_target_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#788
def visit_instance_variable_and_write_node(node); end
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#782
def visit_instance_variable_operator_write_node(node); end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#794
def visit_instance_variable_or_write_node(node); end
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#767
def visit_instance_variable_read_node(node); end
# @foo, = bar
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#800
def visit_instance_variable_target_node(node); end
# ^^^^^^^^
#
# @foo, @bar = 1
# ^^^^ ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#776
def visit_instance_variable_write_node(node); end
# 1
# ^
#
# source://prism//lib/prism/translation/ruby_parser.rb#806
def visit_integer_node(node); end
# if /foo #{bar}/ then end
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#812
def visit_interpolated_match_last_line_node(node); end
# /foo #{bar}/
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#829
def visit_interpolated_regular_expression_node(node); end
# "foo #{bar}"
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#844
def visit_interpolated_string_node(node); end
# :"foo #{bar}"
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#851
def visit_interpolated_symbol_node(node); end
# `foo #{bar}`
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#858
def visit_interpolated_x_string_node(node); end
# -> { it }
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#923
def visit_it_local_variable_read_node(node); end
# foo(bar: baz)
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#929
def visit_keyword_hash_node(node); end
# def foo(**bar); end
# ^^^^^
#
# def foo(**); end
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#938
def visit_keyword_rest_parameter_node(node); end
# -> {}
#
# source://prism//lib/prism/translation/ruby_parser.rb#943
def visit_lambda_node(node); end
# foo &&= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#986
def visit_local_variable_and_write_node(node); end
# foo += bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#980
def visit_local_variable_operator_write_node(node); end
# foo ||= bar
# ^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#992
def visit_local_variable_or_write_node(node); end
# foo
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#961
def visit_local_variable_read_node(node); end
# foo, = bar
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#998
def visit_local_variable_target_node(node); end
# foo = 1
# ^^^^^^^
#
# foo, bar = 1
# ^^^ ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#974
def visit_local_variable_write_node(node); end
# if /foo/ then end
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1004
def visit_match_last_line_node(node); end
# foo in bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1010
def visit_match_predicate_node(node); end
# foo => bar
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1016
def visit_match_required_node(node); end
# /(?<foo>foo)/ =~ bar
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1022
def visit_match_write_node(node); end
# A node that is missing from the syntax tree. This is only used in the
# case of a syntax error. The parser gem doesn't have such a concept, so
# we invent our own here.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1029
def visit_missing_node(node); end
# module Foo; end
# ^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1035
def visit_module_node(node); end
# foo, bar = baz
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1055
def visit_multi_target_node(node); end
# foo, bar = baz
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1065
def visit_multi_write_node(node); end
# next
# ^^^^
#
# next foo
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1089
def visit_next_node(node); end
# nil
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1102
def visit_nil_node(node); end
# def foo(**nil); end
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1108
def visit_no_keywords_parameter_node(node); end
# -> { _1 + _2 }
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1114
def visit_numbered_parameters_node(node); end
# $1
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1120
def visit_numbered_reference_read_node(node); end
# def foo(bar: baz); end
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1126
def visit_optional_keyword_parameter_node(node); end
# def foo(bar = 1); end
# ^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1132
def visit_optional_parameter_node(node); end
# a or b
# ^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1138
def visit_or_node(node); end
# def foo(bar, *baz); end
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1144
def visit_parameters_node(node); end
# ()
# ^^
#
# (1)
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1182
def visit_parentheses_node(node); end
# foo => ^(bar)
# ^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1192
def visit_pinned_expression_node(node); end
# foo = 1 and bar => ^foo
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1198
def visit_pinned_variable_node(node); end
# END {}
#
# source://prism//lib/prism/translation/ruby_parser.rb#1207
def visit_post_execution_node(node); end
# BEGIN {}
#
# source://prism//lib/prism/translation/ruby_parser.rb#1212
def visit_pre_execution_node(node); end
# The top-level program node.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1217
def visit_program_node(node); end
# 0..5
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1223
def visit_range_node(node); end
# 1r
# ^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1245
def visit_rational_node(node); end
# redo
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1251
def visit_redo_node(node); end
# /foo/
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1257
def visit_regular_expression_node(node); end
# def foo(bar:); end
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1263
def visit_required_keyword_parameter_node(node); end
# def foo(bar); end
# ^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1269
def visit_required_parameter_node(node); end
# foo rescue bar
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1275
def visit_rescue_modifier_node(node); end
# begin; rescue; end
# ^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1281
def visit_rescue_node(node); end
# def foo(*bar); end
# ^^^^
#
# def foo(*); end
# ^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1301
def visit_rest_parameter_node(node); end
# retry
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1307
def visit_retry_node(node); end
# return
# ^^^^^^
#
# return 1
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1316
def visit_return_node(node); end
# self
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1329
def visit_self_node(node); end
# A shareable constant.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1334
def visit_shareable_constant_node(node); end
# class << self; end
# ^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1340
def visit_singleton_class_node(node); end
# __ENCODING__
# ^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1348
def visit_source_encoding_node(node); end
# __FILE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1355
def visit_source_file_node(node); end
# __LINE__
# ^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1361
def visit_source_line_node(node); end
# foo(*bar)
# ^^^^
#
# def foo((bar, *baz)); end
# ^^^^
#
# def foo(*); bar(*); end
# ^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1373
def visit_splat_node(node); end
# A list of statements.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1382
def visit_statements_node(node); end
# "foo"
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1394
def visit_string_node(node); end
# super(foo)
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1400
def visit_super_node(node); end
# :foo
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1414
def visit_symbol_node(node); end
# true
# ^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1420
def visit_true_node(node); end
# undef foo
# ^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1426
def visit_undef_node(node); end
# unless foo; bar end
# ^^^^^^^^^^^^^^^^^^^
#
# bar unless foo
# ^^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1436
def visit_unless_node(node); end
# until foo; bar end
# ^^^^^^^^^^^^^^^^^
#
# bar until foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1445
def visit_until_node(node); end
# case foo; when bar; end
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1451
def visit_when_node(node); end
# while foo; bar end
# ^^^^^^^^^^^^^^^^^^
#
# bar while foo
# ^^^^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1460
def visit_while_node(node); end
# `foo`
# ^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1466
def visit_x_string_node(node); end
# yield
# ^^^^^
#
# yield 1
# ^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1482
def visit_yield_node(node); end
private
# If a class variable is written within a method definition, it has a
# different type than everywhere else.
#
# source://prism//lib/prism/translation/ruby_parser.rb#403
def class_variable_write_type; end
# Create a new compiler with the given options.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1489
def copy_compiler(in_def: T.unsafe(nil), in_pattern: T.unsafe(nil)); end
# Call nodes with operators following them will either be op_asgn or
# op_asgn2 nodes. That is determined by their call operator and their
# right-hand side.
#
# @return [Boolean]
#
# source://prism//lib/prism/translation/ruby_parser.rb#308
def op_asgn?(node); end
# Call nodes with operators following them can use &. as an operator,
# which changes their type by prefixing "safe_".
#
# source://prism//lib/prism/translation/ruby_parser.rb#314
def op_asgn_type(node, type); end
# Create a new Sexp object from the given prism node and arguments.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1494
def s(node, *arguments); end
# Visit a block node, which will modify the AST by wrapping the given
# visited node in an iter node.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1504
def visit_block(node, sexp, block); end
# def foo((bar, baz)); end
# ^^^^^^^^^^
#
# source://prism//lib/prism/translation/ruby_parser.rb#1159
def visit_destructured_parameter(node); end
# Visit the interpolated content of the string-like node.
#
# source://prism//lib/prism/translation/ruby_parser.rb#865
def visit_interpolated_parts(parts); end
# Pattern constants get wrapped in another layer of :const.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1525
def visit_pattern_constant(node); end
# If the bounds of a range node are empty parentheses, then they do not
# get replaced by their usual s(:nil), but instead are s(:begin).
#
# source://prism//lib/prism/translation/ruby_parser.rb#1235
def visit_range_bounds_node(node); end
# Visit the value of a write, which will be on the right-hand side of
# a write operator. Because implicit arrays can have splats, those could
# potentially be wrapped in an svalue node.
#
# source://prism//lib/prism/translation/ruby_parser.rb#1539
def visit_write_value(node); end
end
# Represents the use of the literal `true` keyword.
#
# true
# ^^^^
#
# source://prism//lib/prism/node.rb#18041
class Prism::TrueNode < ::Prism::Node
# def initialize: (Location location) -> void
#
# @return [TrueNode] a new instance of TrueNode
#
# source://prism//lib/prism/node.rb#18043
sig { params(source: Prism::Source, location: Prism::Location).void }
def initialize(source, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18116
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18049
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18054
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18064
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18059
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?location: Location) -> TrueNode
#
# source://prism//lib/prism/node.rb#18069
sig { params(location: Prism::Location).returns(Prism::TrueNode) }
def copy(location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18054
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
#
# source://prism//lib/prism/node.rb#18077
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18082
sig { override.returns(String) }
def inspect; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18100
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18110
def type; end
end
end
# Represents the use of the `undef` keyword.
#
# undef :foo, :bar, :baz
# ^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#18125
class Prism::UndefNode < ::Prism::Node
# def initialize: (Array[SymbolNode | InterpolatedSymbolNode] names, Location keyword_loc, Location location) -> void
#
# @return [UndefNode] a new instance of UndefNode
#
# source://prism//lib/prism/node.rb#18127
sig do
params(
source: Prism::Source,
names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
keyword_loc: Prism::Location,
location: Prism::Location
).void
end
def initialize(source, names, keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18217
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18135
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18140
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18150
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18145
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location, ?location: Location) -> UndefNode
#
# source://prism//lib/prism/node.rb#18155
sig do
params(
names: T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)],
keyword_loc: Prism::Location,
location: Prism::Location
).returns(Prism::UndefNode)
end
def copy(names: T.unsafe(nil), keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18140
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location, location: Location }
#
# source://prism//lib/prism/node.rb#18163
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18183
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#18178
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#18171
sig { returns(Prism::Location) }
def keyword_loc; end
# attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
#
# source://prism//lib/prism/node.rb#18168
sig { returns(T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) }
def names; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18201
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18211
def type; end
end
end
# Represents the use of the `unless` keyword, either in the block form or the modifier form.
#
# bar unless foo
# ^^^^^^^^^^^^^^
#
# unless foo then bar end
# ^^^^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#18232
class Prism::UnlessNode < ::Prism::Node
# def initialize: (Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? consequent, Location? end_keyword_loc, Location location) -> void
#
# @return [UnlessNode] a new instance of UnlessNode
#
# source://prism//lib/prism/node.rb#18234
sig do
params(
source: Prism::Source,
keyword_loc: Prism::Location,
predicate: Prism::Node,
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::ElseNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18399
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18246
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18251
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18265
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18256
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# The else clause of the unless expression, if present.
#
# unless cond then bar else baz end
# ^^^^^^^^
#
# source://prism//lib/prism/node.rb#18331
sig { returns(T.nilable(Prism::ElseNode)) }
def consequent; end
# def copy: (?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: ElseNode?, ?end_keyword_loc: Location?, ?location: Location) -> UnlessNode
#
# source://prism//lib/prism/node.rb#18270
sig do
params(
keyword_loc: Prism::Location,
predicate: Prism::Node,
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
consequent: T.nilable(Prism::ElseNode),
end_keyword_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::UnlessNode)
end
def copy(keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), consequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18251
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#18278
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
# def end_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#18360
sig { returns(T.nilable(String)) }
def end_keyword; end
# The location of the `end` keyword, if present.
#
# unless cond then bar end
# ^^^
#
# source://prism//lib/prism/node.rb#18337
sig { returns(T.nilable(Prism::Location)) }
def end_keyword_loc; end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18365
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#18350
sig { returns(String) }
def keyword; end
# The location of the `unless` keyword.
#
# unless cond then bar end
# ^^^^^^
#
# bar unless cond
# ^^^^^^
#
# source://prism//lib/prism/node.rb#18289
sig { returns(Prism::Location) }
def keyword_loc; end
# source://prism//lib/prism/parse_result/newlines.rb#97
def newline!(lines); end
# The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
#
# unless cond then bar end
# ^^^^
#
# bar unless cond
# ^^^^
#
# source://prism//lib/prism/node.rb#18302
sig { returns(Prism::Node) }
def predicate; end
# The body of statements that will executed if the unless condition is
# falsey. Will be `nil` if no body is provided.
#
# unless cond then bar end
# ^^^
#
# source://prism//lib/prism/node.rb#18325
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# def then_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#18355
sig { returns(T.nilable(String)) }
def then_keyword; end
# The location of the `then` keyword, if present.
#
# unless cond then bar end
# ^^^^
#
# source://prism//lib/prism/node.rb#18308
sig { returns(T.nilable(Prism::Location)) }
def then_keyword_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18383
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18393
def type; end
end
end
# Represents the use of the `until` keyword, either in the block form or the modifier form.
#
# bar until foo
# ^^^^^^^^^^^^^
#
# until foo do bar end
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#18417
class Prism::UntilNode < ::Prism::Node
# def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
#
# @return [UntilNode] a new instance of UntilNode
#
# source://prism//lib/prism/node.rb#18419
sig do
params(
source: Prism::Source,
flags: Integer,
keyword_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).void
end
def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18545
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18430
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def begin_modifier?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#18496
sig { returns(T::Boolean) }
def begin_modifier?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18435
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#18506
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#18477
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18448
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18440
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> UntilNode
#
# source://prism//lib/prism/node.rb#18453
sig do
params(
flags: Integer,
keyword_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).returns(Prism::UntilNode)
end
def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18435
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode?, location: Location }
#
# source://prism//lib/prism/node.rb#18461
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18511
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#18501
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#18470
sig { returns(Prism::Location) }
def keyword_loc; end
# source://prism//lib/prism/parse_result/newlines.rb#103
def newline!(lines); end
# attr_reader predicate: Prism::node
#
# source://prism//lib/prism/node.rb#18490
sig { returns(Prism::Node) }
def predicate; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#18493
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18529
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#18466
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18539
def type; end
end
end
# The version constant is set by reading the result of calling pm_version.
Prism::VERSION = T.let(T.unsafe(nil), String)
# A visitor is a class that provides a default implementation for every accept
# method defined on the nodes. This means it can walk a tree without the
# caller needing to define any special handling. This allows you to handle a
# subset of the tree, while still walking the whole tree.
#
# For example, to find all of the method calls that call the `foo` method, you
# could write:
#
# class FooCalls < Prism::Visitor
# def visit_call_node(node)
# if node.name == "foo"
# # Do something with the node
# end
#
# # Call super so that the visitor continues walking the tree
# super
# end
# end
#
# source://prism//lib/prism/visitor.rb#54
class Prism::Visitor < ::Prism::BasicVisitor
# Visit a AliasGlobalVariableNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AliasGlobalVariableNode).void }
def visit_alias_global_variable_node(node); end
# Visit a AliasMethodNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AliasMethodNode).void }
def visit_alias_method_node(node); end
# Visit a AlternationPatternNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AlternationPatternNode).void }
def visit_alternation_pattern_node(node); end
# Visit a AndNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AndNode).void }
def visit_and_node(node); end
# Visit a ArgumentsNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ArgumentsNode).void }
def visit_arguments_node(node); end
# Visit a ArrayNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ArrayNode).void }
def visit_array_node(node); end
# Visit a ArrayPatternNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ArrayPatternNode).void }
def visit_array_pattern_node(node); end
# Visit a AssocNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AssocNode).void }
def visit_assoc_node(node); end
# Visit a AssocSplatNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::AssocSplatNode).void }
def visit_assoc_splat_node(node); end
# Visit a BackReferenceReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BackReferenceReadNode).void }
def visit_back_reference_read_node(node); end
# Visit a BeginNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BeginNode).void }
def visit_begin_node(node); end
# Visit a BlockArgumentNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BlockArgumentNode).void }
def visit_block_argument_node(node); end
# Visit a BlockLocalVariableNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BlockLocalVariableNode).void }
def visit_block_local_variable_node(node); end
# Visit a BlockNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BlockNode).void }
def visit_block_node(node); end
# Visit a BlockParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BlockParameterNode).void }
def visit_block_parameter_node(node); end
# Visit a BlockParametersNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BlockParametersNode).void }
def visit_block_parameters_node(node); end
# Visit a BreakNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::BreakNode).void }
def visit_break_node(node); end
# Visit a CallAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CallAndWriteNode).void }
def visit_call_and_write_node(node); end
# Visit a CallNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CallNode).void }
def visit_call_node(node); end
# Visit a CallOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CallOperatorWriteNode).void }
def visit_call_operator_write_node(node); end
# Visit a CallOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CallOrWriteNode).void }
def visit_call_or_write_node(node); end
# Visit a CallTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CallTargetNode).void }
def visit_call_target_node(node); end
# Visit a CapturePatternNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CapturePatternNode).void }
def visit_capture_pattern_node(node); end
# Visit a CaseMatchNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CaseMatchNode).void }
def visit_case_match_node(node); end
# Visit a CaseNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::CaseNode).void }
def visit_case_node(node); end
# Visit a ClassNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassNode).void }
def visit_class_node(node); end
# Visit a ClassVariableAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableAndWriteNode).void }
def visit_class_variable_and_write_node(node); end
# Visit a ClassVariableOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
def visit_class_variable_operator_write_node(node); end
# Visit a ClassVariableOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableOrWriteNode).void }
def visit_class_variable_or_write_node(node); end
# Visit a ClassVariableReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableReadNode).void }
def visit_class_variable_read_node(node); end
# Visit a ClassVariableTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableTargetNode).void }
def visit_class_variable_target_node(node); end
# Visit a ClassVariableWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ClassVariableWriteNode).void }
def visit_class_variable_write_node(node); end
# Visit a ConstantAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantAndWriteNode).void }
def visit_constant_and_write_node(node); end
# Visit a ConstantOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantOperatorWriteNode).void }
def visit_constant_operator_write_node(node); end
# Visit a ConstantOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantOrWriteNode).void }
def visit_constant_or_write_node(node); end
# Visit a ConstantPathAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathAndWriteNode).void }
def visit_constant_path_and_write_node(node); end
# Visit a ConstantPathNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathNode).void }
def visit_constant_path_node(node); end
# Visit a ConstantPathOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
def visit_constant_path_operator_write_node(node); end
# Visit a ConstantPathOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathOrWriteNode).void }
def visit_constant_path_or_write_node(node); end
# Visit a ConstantPathTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathTargetNode).void }
def visit_constant_path_target_node(node); end
# Visit a ConstantPathWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantPathWriteNode).void }
def visit_constant_path_write_node(node); end
# Visit a ConstantReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantReadNode).void }
def visit_constant_read_node(node); end
# Visit a ConstantTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantTargetNode).void }
def visit_constant_target_node(node); end
# Visit a ConstantWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ConstantWriteNode).void }
def visit_constant_write_node(node); end
# Visit a DefNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::DefNode).void }
def visit_def_node(node); end
# Visit a DefinedNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::DefinedNode).void }
def visit_defined_node(node); end
# Visit a ElseNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ElseNode).void }
def visit_else_node(node); end
# Visit a EmbeddedStatementsNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::EmbeddedStatementsNode).void }
def visit_embedded_statements_node(node); end
# Visit a EmbeddedVariableNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::EmbeddedVariableNode).void }
def visit_embedded_variable_node(node); end
# Visit a EnsureNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::EnsureNode).void }
def visit_ensure_node(node); end
# Visit a FalseNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::FalseNode).void }
def visit_false_node(node); end
# Visit a FindPatternNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::FindPatternNode).void }
def visit_find_pattern_node(node); end
# Visit a FlipFlopNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::FlipFlopNode).void }
def visit_flip_flop_node(node); end
# Visit a FloatNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::FloatNode).void }
def visit_float_node(node); end
# Visit a ForNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ForNode).void }
def visit_for_node(node); end
# Visit a ForwardingArgumentsNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ForwardingArgumentsNode).void }
def visit_forwarding_arguments_node(node); end
# Visit a ForwardingParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ForwardingParameterNode).void }
def visit_forwarding_parameter_node(node); end
# Visit a ForwardingSuperNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ForwardingSuperNode).void }
def visit_forwarding_super_node(node); end
# Visit a GlobalVariableAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableAndWriteNode).void }
def visit_global_variable_and_write_node(node); end
# Visit a GlobalVariableOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableOperatorWriteNode).void }
def visit_global_variable_operator_write_node(node); end
# Visit a GlobalVariableOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableOrWriteNode).void }
def visit_global_variable_or_write_node(node); end
# Visit a GlobalVariableReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableReadNode).void }
def visit_global_variable_read_node(node); end
# Visit a GlobalVariableTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableTargetNode).void }
def visit_global_variable_target_node(node); end
# Visit a GlobalVariableWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::GlobalVariableWriteNode).void }
def visit_global_variable_write_node(node); end
# Visit a HashNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::HashNode).void }
def visit_hash_node(node); end
# Visit a HashPatternNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::HashPatternNode).void }
def visit_hash_pattern_node(node); end
# Visit a IfNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IfNode).void }
def visit_if_node(node); end
# Visit a ImaginaryNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ImaginaryNode).void }
def visit_imaginary_node(node); end
# Visit a ImplicitNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ImplicitNode).void }
def visit_implicit_node(node); end
# Visit a ImplicitRestNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ImplicitRestNode).void }
def visit_implicit_rest_node(node); end
# Visit a InNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InNode).void }
def visit_in_node(node); end
# Visit a IndexAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IndexAndWriteNode).void }
def visit_index_and_write_node(node); end
# Visit a IndexOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IndexOperatorWriteNode).void }
def visit_index_operator_write_node(node); end
# Visit a IndexOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IndexOrWriteNode).void }
def visit_index_or_write_node(node); end
# Visit a IndexTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IndexTargetNode).void }
def visit_index_target_node(node); end
# Visit a InstanceVariableAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableAndWriteNode).void }
def visit_instance_variable_and_write_node(node); end
# Visit a InstanceVariableOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
def visit_instance_variable_operator_write_node(node); end
# Visit a InstanceVariableOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableOrWriteNode).void }
def visit_instance_variable_or_write_node(node); end
# Visit a InstanceVariableReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableReadNode).void }
def visit_instance_variable_read_node(node); end
# Visit a InstanceVariableTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableTargetNode).void }
def visit_instance_variable_target_node(node); end
# Visit a InstanceVariableWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InstanceVariableWriteNode).void }
def visit_instance_variable_write_node(node); end
# Visit a IntegerNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::IntegerNode).void }
def visit_integer_node(node); end
# Visit a InterpolatedMatchLastLineNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InterpolatedMatchLastLineNode).void }
def visit_interpolated_match_last_line_node(node); end
# Visit a InterpolatedRegularExpressionNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InterpolatedRegularExpressionNode).void }
def visit_interpolated_regular_expression_node(node); end
# Visit a InterpolatedStringNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InterpolatedStringNode).void }
def visit_interpolated_string_node(node); end
# Visit a InterpolatedSymbolNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InterpolatedSymbolNode).void }
def visit_interpolated_symbol_node(node); end
# Visit a InterpolatedXStringNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::InterpolatedXStringNode).void }
def visit_interpolated_x_string_node(node); end
# Visit a ItLocalVariableReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ItLocalVariableReadNode).void }
def visit_it_local_variable_read_node(node); end
# Visit a ItParametersNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ItParametersNode).void }
def visit_it_parameters_node(node); end
# Visit a KeywordHashNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::KeywordHashNode).void }
def visit_keyword_hash_node(node); end
# Visit a KeywordRestParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::KeywordRestParameterNode).void }
def visit_keyword_rest_parameter_node(node); end
# Visit a LambdaNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LambdaNode).void }
def visit_lambda_node(node); end
# Visit a LocalVariableAndWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableAndWriteNode).void }
def visit_local_variable_and_write_node(node); end
# Visit a LocalVariableOperatorWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
def visit_local_variable_operator_write_node(node); end
# Visit a LocalVariableOrWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableOrWriteNode).void }
def visit_local_variable_or_write_node(node); end
# Visit a LocalVariableReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableReadNode).void }
def visit_local_variable_read_node(node); end
# Visit a LocalVariableTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableTargetNode).void }
def visit_local_variable_target_node(node); end
# Visit a LocalVariableWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::LocalVariableWriteNode).void }
def visit_local_variable_write_node(node); end
# Visit a MatchLastLineNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MatchLastLineNode).void }
def visit_match_last_line_node(node); end
# Visit a MatchPredicateNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MatchPredicateNode).void }
def visit_match_predicate_node(node); end
# Visit a MatchRequiredNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MatchRequiredNode).void }
def visit_match_required_node(node); end
# Visit a MatchWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MatchWriteNode).void }
def visit_match_write_node(node); end
# Visit a MissingNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MissingNode).void }
def visit_missing_node(node); end
# Visit a ModuleNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ModuleNode).void }
def visit_module_node(node); end
# Visit a MultiTargetNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MultiTargetNode).void }
def visit_multi_target_node(node); end
# Visit a MultiWriteNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::MultiWriteNode).void }
def visit_multi_write_node(node); end
# Visit a NextNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::NextNode).void }
def visit_next_node(node); end
# Visit a NilNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::NilNode).void }
def visit_nil_node(node); end
# Visit a NoKeywordsParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::NoKeywordsParameterNode).void }
def visit_no_keywords_parameter_node(node); end
# Visit a NumberedParametersNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::NumberedParametersNode).void }
def visit_numbered_parameters_node(node); end
# Visit a NumberedReferenceReadNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::NumberedReferenceReadNode).void }
def visit_numbered_reference_read_node(node); end
# Visit a OptionalKeywordParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::OptionalKeywordParameterNode).void }
def visit_optional_keyword_parameter_node(node); end
# Visit a OptionalParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::OptionalParameterNode).void }
def visit_optional_parameter_node(node); end
# Visit a OrNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::OrNode).void }
def visit_or_node(node); end
# Visit a ParametersNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ParametersNode).void }
def visit_parameters_node(node); end
# Visit a ParenthesesNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ParenthesesNode).void }
def visit_parentheses_node(node); end
# Visit a PinnedExpressionNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::PinnedExpressionNode).void }
def visit_pinned_expression_node(node); end
# Visit a PinnedVariableNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::PinnedVariableNode).void }
def visit_pinned_variable_node(node); end
# Visit a PostExecutionNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::PostExecutionNode).void }
def visit_post_execution_node(node); end
# Visit a PreExecutionNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::PreExecutionNode).void }
def visit_pre_execution_node(node); end
# Visit a ProgramNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ProgramNode).void }
def visit_program_node(node); end
# Visit a RangeNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RangeNode).void }
def visit_range_node(node); end
# Visit a RationalNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RationalNode).void }
def visit_rational_node(node); end
# Visit a RedoNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RedoNode).void }
def visit_redo_node(node); end
# Visit a RegularExpressionNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RegularExpressionNode).void }
def visit_regular_expression_node(node); end
# Visit a RequiredKeywordParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RequiredKeywordParameterNode).void }
def visit_required_keyword_parameter_node(node); end
# Visit a RequiredParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RequiredParameterNode).void }
def visit_required_parameter_node(node); end
# Visit a RescueModifierNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RescueModifierNode).void }
def visit_rescue_modifier_node(node); end
# Visit a RescueNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RescueNode).void }
def visit_rescue_node(node); end
# Visit a RestParameterNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RestParameterNode).void }
def visit_rest_parameter_node(node); end
# Visit a RetryNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::RetryNode).void }
def visit_retry_node(node); end
# Visit a ReturnNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ReturnNode).void }
def visit_return_node(node); end
# Visit a SelfNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SelfNode).void }
def visit_self_node(node); end
# Visit a ShareableConstantNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::ShareableConstantNode).void }
def visit_shareable_constant_node(node); end
# Visit a SingletonClassNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SingletonClassNode).void }
def visit_singleton_class_node(node); end
# Visit a SourceEncodingNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SourceEncodingNode).void }
def visit_source_encoding_node(node); end
# Visit a SourceFileNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SourceFileNode).void }
def visit_source_file_node(node); end
# Visit a SourceLineNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SourceLineNode).void }
def visit_source_line_node(node); end
# Visit a SplatNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SplatNode).void }
def visit_splat_node(node); end
# Visit a StatementsNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::StatementsNode).void }
def visit_statements_node(node); end
# Visit a StringNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::StringNode).void }
def visit_string_node(node); end
# Visit a SuperNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SuperNode).void }
def visit_super_node(node); end
# Visit a SymbolNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::SymbolNode).void }
def visit_symbol_node(node); end
# Visit a TrueNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::TrueNode).void }
def visit_true_node(node); end
# Visit a UndefNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::UndefNode).void }
def visit_undef_node(node); end
# Visit a UnlessNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::UnlessNode).void }
def visit_unless_node(node); end
# Visit a UntilNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::UntilNode).void }
def visit_until_node(node); end
# Visit a WhenNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::WhenNode).void }
def visit_when_node(node); end
# Visit a WhileNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::WhileNode).void }
def visit_while_node(node); end
# Visit a XStringNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::XStringNode).void }
def visit_x_string_node(node); end
# Visit a YieldNode node
#
# source://prism//lib/prism/visitor.rb#29
sig { params(node: Prism::YieldNode).void }
def visit_yield_node(node); end
end
# Represents the use of the `when` keyword within a case statement.
#
# case true
# when true
# ^^^^^^^^^
# end
#
# source://prism//lib/prism/node.rb#18561
class Prism::WhenNode < ::Prism::Node
# def initialize: (Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements, Location location) -> void
#
# @return [WhenNode] a new instance of WhenNode
#
# source://prism//lib/prism/node.rb#18563
sig do
params(
source: Prism::Source,
keyword_loc: Prism::Location,
conditions: T::Array[Prism::Node],
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).void
end
def initialize(source, keyword_loc, conditions, then_keyword_loc, statements, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18679
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18573
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18578
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18591
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18583
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# attr_reader conditions: Array[Prism::node]
#
# source://prism//lib/prism/node.rb#18616
sig { returns(T::Array[Prism::Node]) }
def conditions; end
# def copy: (?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?location: Location) -> WhenNode
#
# source://prism//lib/prism/node.rb#18596
sig do
params(
keyword_loc: Prism::Location,
conditions: T::Array[Prism::Node],
then_keyword_loc: T.nilable(Prism::Location),
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).returns(Prism::WhenNode)
end
def copy(keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18578
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode?, location: Location }
#
# source://prism//lib/prism/node.rb#18604
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18645
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#18635
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#18609
sig { returns(Prism::Location) }
def keyword_loc; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#18632
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# def then_keyword: () -> String?
#
# source://prism//lib/prism/node.rb#18640
sig { returns(T.nilable(String)) }
def then_keyword; end
# attr_reader then_keyword_loc: Location?
#
# source://prism//lib/prism/node.rb#18619
sig { returns(T.nilable(Prism::Location)) }
def then_keyword_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18663
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18673
def type; end
end
end
# Represents the use of the `while` keyword, either in the block form or the modifier form.
#
# bar while foo
# ^^^^^^^^^^^^^
#
# while foo do bar end
# ^^^^^^^^^^^^^^^^^^^^
#
# source://prism//lib/prism/node.rb#18696
class Prism::WhileNode < ::Prism::Node
# def initialize: (Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
#
# @return [WhileNode] a new instance of WhileNode
#
# source://prism//lib/prism/node.rb#18698
sig do
params(
source: Prism::Source,
flags: Integer,
keyword_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).void
end
def initialize(source, flags, keyword_loc, closing_loc, predicate, statements, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18824
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18709
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def begin_modifier?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#18775
sig { returns(T::Boolean) }
def begin_modifier?; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18714
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String?
#
# source://prism//lib/prism/node.rb#18785
sig { returns(T.nilable(String)) }
def closing; end
# attr_reader closing_loc: Location?
#
# source://prism//lib/prism/node.rb#18756
sig { returns(T.nilable(Prism::Location)) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18727
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18719
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> WhileNode
#
# source://prism//lib/prism/node.rb#18732
sig do
params(
flags: Integer,
keyword_loc: Prism::Location,
closing_loc: T.nilable(Prism::Location),
predicate: Prism::Node,
statements: T.nilable(Prism::StatementsNode),
location: Prism::Location
).returns(Prism::WhileNode)
end
def copy(flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18714
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode?, location: Location }
#
# source://prism//lib/prism/node.rb#18740
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18790
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#18780
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#18749
sig { returns(Prism::Location) }
def keyword_loc; end
# source://prism//lib/prism/parse_result/newlines.rb#109
def newline!(lines); end
# attr_reader predicate: Prism::node
#
# source://prism//lib/prism/node.rb#18769
sig { returns(Prism::Node) }
def predicate; end
# attr_reader statements: StatementsNode?
#
# source://prism//lib/prism/node.rb#18772
sig { returns(T.nilable(Prism::StatementsNode)) }
def statements; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18808
sig { override.returns(Symbol) }
def type; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#18745
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18818
def type; end
end
end
# Represents an xstring literal with no interpolation.
#
# `foo`
# ^^^^^
#
# source://prism//lib/prism/node.rb#18838
class Prism::XStringNode < ::Prism::Node
include ::Prism::HeredocQuery
# def initialize: (Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
#
# @return [XStringNode] a new instance of XStringNode
#
# source://prism//lib/prism/node.rb#18840
sig do
params(
source: Prism::Source,
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).void
end
def initialize(source, flags, opening_loc, content_loc, closing_loc, unescaped, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#18971
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18851
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18856
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def closing: () -> String
#
# source://prism//lib/prism/node.rb#18932
sig { returns(String) }
def closing; end
# attr_reader closing_loc: Location
#
# source://prism//lib/prism/node.rb#18902
sig { returns(Prism::Location) }
def closing_loc; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#18866
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#18861
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def content: () -> String
#
# source://prism//lib/prism/node.rb#18927
sig { returns(String) }
def content; end
# attr_reader content_loc: Location
#
# source://prism//lib/prism/node.rb#18895
sig { returns(Prism::Location) }
def content_loc; end
# def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> XStringNode
#
# source://prism//lib/prism/node.rb#18871
sig do
params(
flags: Integer,
opening_loc: Prism::Location,
content_loc: Prism::Location,
closing_loc: Prism::Location,
unescaped: String,
location: Prism::Location
).returns(Prism::XStringNode)
end
def copy(flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#18856
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
#
# source://prism//lib/prism/node.rb#18879
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def forced_binary_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#18917
sig { returns(T::Boolean) }
def forced_binary_encoding?; end
# def forced_utf8_encoding?: () -> bool
#
# @return [Boolean]
#
# source://prism//lib/prism/node.rb#18912
sig { returns(T::Boolean) }
def forced_utf8_encoding?; end
sig { returns(T::Boolean) }
def heredoc?; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#18937
sig { override.returns(String) }
def inspect; end
# def opening: () -> String
#
# source://prism//lib/prism/node.rb#18922
sig { returns(String) }
def opening; end
# attr_reader opening_loc: Location
#
# source://prism//lib/prism/node.rb#18888
sig { returns(Prism::Location) }
def opening_loc; end
# Occasionally it's helpful to treat a string as if it were interpolated so
# that there's a consistent interface for working with strings.
#
# source://prism//lib/prism/node_ext.rb#86
sig { returns(Prism::InterpolatedXStringNode) }
def to_interpolated; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18955
sig { override.returns(Symbol) }
def type; end
# attr_reader unescaped: String
#
# source://prism//lib/prism/node.rb#18909
sig { returns(String) }
def unescaped; end
protected
# protected attr_reader flags: Integer
#
# source://prism//lib/prism/node.rb#18884
sig { returns(Integer) }
def flags; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#18965
def type; end
end
end
# Represents the use of the `yield` keyword.
#
# yield 1
# ^^^^^^^
#
# source://prism//lib/prism/node.rb#18985
class Prism::YieldNode < ::Prism::Node
# def initialize: (Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Location location) -> void
#
# @return [YieldNode] a new instance of YieldNode
#
# source://prism//lib/prism/node.rb#18987
sig do
params(
source: Prism::Source,
keyword_loc: Prism::Location,
lparen_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
rparen_loc: T.nilable(Prism::Location),
location: Prism::Location
).void
end
def initialize(source, keyword_loc, lparen_loc, arguments, rparen_loc, location); end
# Implements case-equality for the node. This is effectively == but without
# comparing the value of locations. Locations are checked only for presence.
#
# source://prism//lib/prism/node.rb#19117
def ===(other); end
# def accept: (Visitor visitor) -> void
#
# source://prism//lib/prism/node.rb#18997
sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
def accept(visitor); end
# attr_reader arguments: ArgumentsNode?
#
# source://prism//lib/prism/node.rb#19052
sig { returns(T.nilable(Prism::ArgumentsNode)) }
def arguments; end
# def child_nodes: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#19002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def child_nodes; end
# def comment_targets: () -> Array[Node | Location]
#
# source://prism//lib/prism/node.rb#19014
sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
def comment_targets; end
# def compact_child_nodes: () -> Array[Node]
#
# source://prism//lib/prism/node.rb#19007
sig { override.returns(T::Array[Prism::Node]) }
def compact_child_nodes; end
# def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?location: Location) -> YieldNode
#
# source://prism//lib/prism/node.rb#19019
sig do
params(
keyword_loc: Prism::Location,
lparen_loc: T.nilable(Prism::Location),
arguments: T.nilable(Prism::ArgumentsNode),
rparen_loc: T.nilable(Prism::Location),
location: Prism::Location
).returns(Prism::YieldNode)
end
def copy(keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), location: T.unsafe(nil)); end
# def child_nodes: () -> Array[nil | Node]
# def deconstruct: () -> Array[nil | Node]
#
# source://prism//lib/prism/node.rb#19002
sig { override.returns(T::Array[T.nilable(Prism::Node)]) }
def deconstruct; end
# def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location }
#
# source://prism//lib/prism/node.rb#19027
sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
def deconstruct_keys(keys); end
sig { override.returns(T::Array[Prism::Reflection::Field]) }
def fields; end
# def inspect -> String
#
# source://prism//lib/prism/node.rb#19083
sig { override.returns(String) }
def inspect; end
# def keyword: () -> String
#
# source://prism//lib/prism/node.rb#19068
sig { returns(String) }
def keyword; end
# attr_reader keyword_loc: Location
#
# source://prism//lib/prism/node.rb#19032
sig { returns(Prism::Location) }
def keyword_loc; end
# def lparen: () -> String?
#
# source://prism//lib/prism/node.rb#19073
sig { returns(T.nilable(String)) }
def lparen; end
# attr_reader lparen_loc: Location?
#
# source://prism//lib/prism/node.rb#19039
sig { returns(T.nilable(Prism::Location)) }
def lparen_loc; end
# def rparen: () -> String?
#
# source://prism//lib/prism/node.rb#19078
sig { returns(T.nilable(String)) }
def rparen; end
# attr_reader rparen_loc: Location?
#
# source://prism//lib/prism/node.rb#19055
sig { returns(T.nilable(Prism::Location)) }
def rparen_loc; end
# Sometimes you want to check an instance of a node against a list of
# classes to see what kind of behavior to perform. Usually this is done by
# calling `[cls1, cls2].include?(node.class)` or putting the node into a
# case statement and doing `case node; when cls1; when cls2; end`. Both of
# these approaches are relatively slow because of the constant lookups,
# method calls, and/or array allocations.
#
# Instead, you can call #type, which will return to you a symbol that you
# can use for comparison. This is faster than the other approaches because
# it uses a single integer comparison, but also because if you're on CRuby
# you can take advantage of the fact that case statements with all symbol
# keys will use a jump table.
#
# def type: () -> Symbol
#
# source://prism//lib/prism/node.rb#19101
sig { override.returns(Symbol) }
def type; end
class << self
# Similar to #type, this method returns a symbol that you can use for
# splitting on the type of the node without having to do a long === chain.
# Note that like #type, it will still be slower than using == for a single
# class, but should be faster in a case statement or an array comparison.
#
# def self.type: () -> Symbol
#
# source://prism//lib/prism/node.rb#19111
def type; end
end
end