# This file is generated by the templates/template.rb script and should not be # modified manually. See templates/sig/prism/node.rbs.erb # if you are looking to modify the template module Prism class Node attr_reader source: Source attr_reader node_id: Integer attr_reader location: Location attr_reader flags: Integer def newline?: () -> bool def static_literal?: () -> bool def accept: (_Visitor) -> void def child_nodes: () -> Array[Prism::node?] def comment_targets: () -> Array[Prism::node | Location] def compact_child_nodes: () -> Array[Prism::node] def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] def self.fields: () -> Array[Prism::Reflection::Field] def type: () -> Symbol def self.type: () -> Symbol def source_lines: () -> Array[String] alias script_lines source_lines def slice: () -> String def slice_lines: () -> String def pretty_print: (untyped q) -> untyped def to_dot: () -> String def tunnel: (Integer line, Integer column) -> Array[Prism::node] def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node? alias find breadth_first_search def breadth_first_search_all: () { (Prism::node) -> bool } -> Array[Prism::node] alias find_all breadth_first_search_all def newline!: (Array[untyped]) -> void def save: (_Repository repository) -> void def save_location: (_Repository repository) -> void def leading_comments: () -> Array[comment] def trailing_comments: () -> Array[comment] def comments: () -> Array[comment] def start_offset: () -> Integer def start_character_offset: () -> Integer def start_code_units_offset: (Encoding encoding) -> Integer def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer def end_offset: () -> Integer def end_character_offset: () -> Integer def end_code_units_offset: (Encoding encoding) -> Integer def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer def start_line: () -> Integer def end_line: () -> Integer def start_column: () -> Integer def start_character_column: () -> Integer def start_code_units_column: (Encoding encoding) -> Integer def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer def end_column: () -> Integer def end_character_column: () -> Integer def end_code_units_column: (Encoding encoding) -> Integer def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer end # Methods implemented by every subclass of Node interface _Node def deconstruct: () -> Array[Prism::node?] def inspect: () -> String end type node = Node & _Node interface _Repository def enter: (Integer node_id, Symbol field_name) -> void end # Represents the use of the `alias` keyword to alias a global variable. # # alias $foo $bar # ^^^^^^^^^^^^^^^ class AliasGlobalVariableNode < Node include _Node attr_reader new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode attr_reader old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode attr_reader keyword_loc: Location def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode new_name, GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode old_name, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location } def keyword: () -> String def type: () -> :alias_global_variable_node | ... def self.type: () -> :alias_global_variable_node end # Represents the use of the `alias` keyword to alias a method. # # alias foo bar # ^^^^^^^^^^^^^ class AliasMethodNode < Node include _Node attr_reader new_name: SymbolNode | InterpolatedSymbolNode attr_reader old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode attr_reader keyword_loc: Location def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, SymbolNode | InterpolatedSymbolNode new_name, SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode old_name, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location } def keyword: () -> String def type: () -> :alias_method_node | ... def self.type: () -> :alias_method_node end # Represents an alternation pattern in pattern matching. # # foo => bar | baz # ^^^^^^^^^ class AlternationPatternNode < Node include _Node attr_reader left: Prism::node attr_reader right: Prism::node attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :alternation_pattern_node | ... def self.type: () -> :alternation_pattern_node end # Represents the use of the `&&` operator or the `and` keyword. # # left and right # ^^^^^^^^^^^^^^ class AndNode < Node include _Node attr_reader left: Prism::node attr_reader right: Prism::node attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :and_node | ... def self.type: () -> :and_node end # Represents a set of arguments to a method or a keyword. # # return foo, bar, baz # ^^^^^^^^^^^^^ class ArgumentsNode < Node include _Node def contains_forwarding?: () -> bool def contains_keywords?: () -> bool def contains_keyword_splat?: () -> bool def contains_splat?: () -> bool def contains_multiple_splats?: () -> bool attr_reader arguments: Array[Prism::node] def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] arguments) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] } def type: () -> :arguments_node | ... def self.type: () -> :arguments_node end # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i. # # [1, 2, 3] # ^^^^^^^^^ class ArrayNode < Node include _Node def contains_splat?: () -> bool attr_reader elements: Array[Prism::node] attr_reader opening_loc: Location? attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] elements, Location? opening_loc, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :array_node | ... def self.type: () -> :array_node end # Represents an array pattern in pattern matching. # # foo in 1, 2 # ^^^^^^^^^^^ # # foo in [1, 2] # ^^^^^^^^^^^^^ # # foo in *bar # ^^^^^^^^^^^ # # foo in Bar[] # ^^^^^^^^^^^^ # # foo in Bar[1, 2, 3] # ^^^^^^^^^^^^^^^^^^^ class ArrayPatternNode < Node include _Node attr_reader constant: ConstantPathNode | ConstantReadNode | nil attr_reader requireds: Array[Prism::node] attr_reader rest: Prism::node? attr_reader posts: Array[Prism::node] attr_reader opening_loc: Location? attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, Array[Prism::node] requireds, Prism::node? rest, Array[Prism::node] posts, Location? opening_loc, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :array_pattern_node | ... def self.type: () -> :array_pattern_node end # Represents a hash key/value pair. # # { a => b } # ^^^^^^ class AssocNode < Node include _Node attr_reader key: Prism::node attr_reader value: Prism::node attr_reader operator_loc: Location? def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node key, Prism::node value, Location? operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? } def operator: () -> String? def type: () -> :assoc_node | ... def self.type: () -> :assoc_node end # Represents a splat in a hash literal. # # { **foo } # ^^^^^ class AssocSplatNode < Node include _Node attr_reader value: Prism::node? attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location } def operator: () -> String def type: () -> :assoc_splat_node | ... def self.type: () -> :assoc_splat_node end # Represents reading a reference to a field in the previous match. # # $' # ^^ class BackReferenceReadNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :back_reference_read_node | ... def self.type: () -> :back_reference_read_node end # Represents a begin statement. # # begin # foo # end # ^^^^^ class BeginNode < Node include _Node attr_reader begin_keyword_loc: Location? attr_reader statements: StatementsNode? attr_reader rescue_clause: RescueNode? attr_reader else_clause: ElseNode? attr_reader ensure_clause: EnsureNode? attr_reader end_keyword_loc: Location? def save_begin_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? } def begin_keyword: () -> String? def end_keyword: () -> String? def type: () -> :begin_node | ... def self.type: () -> :begin_node end # Represents a block argument using `&`. # # bar(&args) # ^^^^^^^^^^ class BlockArgumentNode < Node include _Node attr_reader expression: Prism::node? attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? expression, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location } def operator: () -> String def type: () -> :block_argument_node | ... def self.type: () -> :block_argument_node end # Represents a block local variable. # # a { |; b| } # ^ class BlockLocalVariableNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :block_local_variable_node | ... def self.type: () -> :block_local_variable_node end # Represents a block of ruby code. # # [1, 2, 3].each { |i| puts x } # ^^^^^^^^^^^^^^ class BlockNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil attr_reader body: StatementsNode | BeginNode | nil attr_reader opening_loc: Location attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, BlockParametersNode | NumberedParametersNode | ItParametersNode | nil parameters, StatementsNode | BeginNode | nil body, Location opening_loc, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :block_node | ... def self.type: () -> :block_node end # Represents a block parameter of a method, block, or lambda definition. # # def a(&b) # ^^ # end class BlockParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol? attr_reader name_loc: Location? attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } def operator: () -> String def type: () -> :block_parameter_node | ... def self.type: () -> :block_parameter_node end # Represents a block's parameters declaration. # # -> (a, b = 1; local) { } # ^^^^^^^^^^^^^^^^^ # # foo do |a, b = 1; local| # ^^^^^^^^^^^^^^^^^ # end class BlockParametersNode < Node include _Node attr_reader parameters: ParametersNode? attr_reader locals: Array[BlockLocalVariableNode] attr_reader opening_loc: Location? attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ParametersNode? parameters, Array[BlockLocalVariableNode] locals, Location? opening_loc, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :block_parameters_node | ... def self.type: () -> :block_parameters_node end # Represents the use of the `break` keyword. # # break foo # ^^^^^^^^^ class BreakNode < Node include _Node attr_reader arguments: ArgumentsNode? attr_reader keyword_loc: Location def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ArgumentsNode? arguments, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location } def keyword: () -> String def type: () -> :break_node | ... def self.type: () -> :break_node end # Represents the use of the `&&=` operator on a call. # # foo.bar &&= value # ^^^^^^^^^^^^^^^^^ class CallAndWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader message_loc: Location? attr_reader read_name: Symbol attr_reader write_name: Symbol attr_reader operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_message_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node } def call_operator: () -> String? def message: () -> String? def operator: () -> String def type: () -> :call_and_write_node | ... def self.type: () -> :call_and_write_node end # Represents a method call, in all of the various forms that can take. # # foo # ^^^ # # foo() # ^^^^^ # # +foo # ^^^^ # # foo + bar # ^^^^^^^^^ # # foo.bar # ^^^^^^^ # # foo&.bar # ^^^^^^^^ class CallNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader name: Symbol attr_reader message_loc: Location? attr_reader opening_loc: Location? attr_reader arguments: ArgumentsNode? attr_reader closing_loc: Location? attr_reader equal_loc: Location? attr_reader block: BlockNode | BlockArgumentNode | nil def save_call_operator_loc: (_Repository repository) -> void def save_message_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def save_equal_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Location? equal_loc, BlockNode | BlockArgumentNode | nil block) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?equal_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, equal_loc: Location?, block: BlockNode | BlockArgumentNode | nil } def call_operator: () -> String? def message: () -> String? def opening: () -> String? def closing: () -> String? def equal: () -> String? def type: () -> :call_node | ... def self.type: () -> :call_node end # Represents the use of an assignment operator on a call. # # foo.bar += baz # ^^^^^^^^^^^^^^ class CallOperatorWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader message_loc: Location? attr_reader read_name: Symbol attr_reader write_name: Symbol attr_reader binary_operator: Symbol attr_reader binary_operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_message_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, 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) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node } def call_operator: () -> String? def message: () -> String? def type: () -> :call_operator_write_node | ... def self.type: () -> :call_operator_write_node end # Represents the use of the `||=` operator on a call. # # foo.bar ||= value # ^^^^^^^^^^^^^^^^^ class CallOrWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader message_loc: Location? attr_reader read_name: Symbol attr_reader write_name: Symbol attr_reader operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_message_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node } def call_operator: () -> String? def message: () -> String? def operator: () -> String def type: () -> :call_or_write_node | ... def self.type: () -> :call_or_write_node end # Represents assigning to a method call. # # foo.bar, = 1 # ^^^^^^^ # # begin # rescue => foo.bar # ^^^^^^^ # end # # for foo.bar in baz do end # ^^^^^^^ class CallTargetNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node attr_reader call_operator_loc: Location attr_reader name: Symbol attr_reader message_loc: Location def save_call_operator_loc: (_Repository repository) -> void def save_message_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node receiver, Location call_operator_loc, Symbol name, Location message_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location } def call_operator: () -> String def message: () -> String def type: () -> :call_target_node | ... def self.type: () -> :call_target_node end # Represents assigning to a local variable in pattern matching. # # foo => [bar => baz] # ^^^^^^^^^^^^ class CapturePatternNode < Node include _Node attr_reader value: Prism::node attr_reader target: LocalVariableTargetNode attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, LocalVariableTargetNode target, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location } def operator: () -> String def type: () -> :capture_pattern_node | ... def self.type: () -> :capture_pattern_node end # Represents the use of a case statement for pattern matching. # # case true # in false # end # ^^^^^^^^^ class CaseMatchNode < Node include _Node attr_reader predicate: Prism::node? attr_reader conditions: Array[InNode] attr_reader else_clause: ElseNode? attr_reader case_keyword_loc: Location attr_reader end_keyword_loc: Location def save_case_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? predicate, Array[InNode] conditions, ElseNode? else_clause, Location case_keyword_loc, Location end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location } def case_keyword: () -> String def end_keyword: () -> String def type: () -> :case_match_node | ... def self.type: () -> :case_match_node end # Represents the use of a case statement. # # case true # when false # end # ^^^^^^^^^^ class CaseNode < Node include _Node attr_reader predicate: Prism::node? attr_reader conditions: Array[WhenNode] attr_reader else_clause: ElseNode? attr_reader case_keyword_loc: Location attr_reader end_keyword_loc: Location def save_case_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? predicate, Array[WhenNode] conditions, ElseNode? else_clause, Location case_keyword_loc, Location end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location } def case_keyword: () -> String def end_keyword: () -> String def type: () -> :case_node | ... def self.type: () -> :case_node end # Represents a class declaration involving the `class` keyword. # # class Foo end # ^^^^^^^^^^^^^ class ClassNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader class_keyword_loc: Location attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode attr_reader inheritance_operator_loc: Location? attr_reader superclass: Prism::node? attr_reader body: StatementsNode | BeginNode | nil attr_reader end_keyword_loc: Location attr_reader name: Symbol def save_class_keyword_loc: (_Repository repository) -> void def save_inheritance_operator_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location class_keyword_loc, ConstantReadNode | ConstantPathNode | CallNode constant_path, Location? inheritance_operator_loc, Prism::node? superclass, StatementsNode | BeginNode | nil body, Location end_keyword_loc, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol } def class_keyword: () -> String def inheritance_operator: () -> String? def end_keyword: () -> String def type: () -> :class_node | ... def self.type: () -> :class_node end # Represents the use of the `&&=` operator for assignment to a class variable. # # @@target &&= value # ^^^^^^^^^^^^^^^^^^ class ClassVariableAndWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :class_variable_and_write_node | ... def self.type: () -> :class_variable_and_write_node end # Represents assigning to a class variable using an operator that isn't `=`. # # @@target += value # ^^^^^^^^^^^^^^^^^ class ClassVariableOperatorWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader binary_operator: Symbol def save_name_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } def type: () -> :class_variable_operator_write_node | ... def self.type: () -> :class_variable_operator_write_node end # Represents the use of the `||=` operator for assignment to a class variable. # # @@target ||= value # ^^^^^^^^^^^^^^^^^^ class ClassVariableOrWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :class_variable_or_write_node | ... def self.type: () -> :class_variable_or_write_node end # Represents referencing a class variable. # # @@foo # ^^^^^ class ClassVariableReadNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :class_variable_read_node | ... def self.type: () -> :class_variable_read_node end # Represents writing to a class variable in a context that doesn't have an explicit value. # # @@foo, @@bar = baz # ^^^^^ ^^^^^ class ClassVariableTargetNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :class_variable_target_node | ... def self.type: () -> :class_variable_target_node end # Represents writing to a class variable. # # @@foo = 1 # ^^^^^^^^^ class ClassVariableWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader value: Prism::node attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :class_variable_write_node | ... def self.type: () -> :class_variable_write_node end # Represents the use of the `&&=` operator for assignment to a constant. # # Target &&= value # ^^^^^^^^^^^^^^^^ class ConstantAndWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :constant_and_write_node | ... def self.type: () -> :constant_and_write_node end # Represents assigning to a constant using an operator that isn't `=`. # # Target += value # ^^^^^^^^^^^^^^^ class ConstantOperatorWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader binary_operator: Symbol def save_name_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } def type: () -> :constant_operator_write_node | ... def self.type: () -> :constant_operator_write_node end # Represents the use of the `||=` operator for assignment to a constant. # # Target ||= value # ^^^^^^^^^^^^^^^^ class ConstantOrWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :constant_or_write_node | ... def self.type: () -> :constant_or_write_node end # Represents the use of the `&&=` operator for assignment to a constant path. # # Parent::Child &&= value # ^^^^^^^^^^^^^^^^^^^^^^^ class ConstantPathAndWriteNode < Node include _Node attr_reader target: ConstantPathNode attr_reader operator_loc: Location attr_reader value: Prism::node def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :constant_path_and_write_node | ... def self.type: () -> :constant_path_and_write_node end # Represents accessing a constant through a path of `::` operators. # # Foo::Bar # ^^^^^^^^ class ConstantPathNode < Node include _Node attr_reader parent: Prism::node? attr_reader name: Symbol? attr_reader delimiter_loc: Location attr_reader name_loc: Location def save_delimiter_loc: (_Repository repository) -> void def save_name_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location } def delimiter: () -> String def type: () -> :constant_path_node | ... def self.type: () -> :constant_path_node end # Represents assigning to a constant path using an operator that isn't `=`. # # Parent::Child += value # ^^^^^^^^^^^^^^^^^^^^^^ class ConstantPathOperatorWriteNode < Node include _Node attr_reader target: ConstantPathNode attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader binary_operator: Symbol def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } def type: () -> :constant_path_operator_write_node | ... def self.type: () -> :constant_path_operator_write_node end # Represents the use of the `||=` operator for assignment to a constant path. # # Parent::Child ||= value # ^^^^^^^^^^^^^^^^^^^^^^^ class ConstantPathOrWriteNode < Node include _Node attr_reader target: ConstantPathNode attr_reader operator_loc: Location attr_reader value: Prism::node def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :constant_path_or_write_node | ... def self.type: () -> :constant_path_or_write_node end # Represents writing to a constant path in a context that doesn't have an explicit value. # # Foo::Foo, Bar::Bar = baz # ^^^^^^^^ ^^^^^^^^ class ConstantPathTargetNode < Node include _Node attr_reader parent: Prism::node? attr_reader name: Symbol? attr_reader delimiter_loc: Location attr_reader name_loc: Location def save_delimiter_loc: (_Repository repository) -> void def save_name_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location } def delimiter: () -> String def type: () -> :constant_path_target_node | ... def self.type: () -> :constant_path_target_node end # Represents writing to a constant path. # # ::Foo = 1 # ^^^^^^^^^ # # Foo::Bar = 1 # ^^^^^^^^^^^^ # # ::Foo::Bar = 1 # ^^^^^^^^^^^^^^ class ConstantPathWriteNode < Node include _Node attr_reader target: ConstantPathNode attr_reader operator_loc: Location attr_reader value: Prism::node def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :constant_path_write_node | ... def self.type: () -> :constant_path_write_node end # Represents referencing a constant. # # Foo # ^^^ class ConstantReadNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :constant_read_node | ... def self.type: () -> :constant_read_node end # Represents writing to a constant in a context that doesn't have an explicit value. # # Foo, Bar = baz # ^^^ ^^^ class ConstantTargetNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :constant_target_node | ... def self.type: () -> :constant_target_node end # Represents writing to a constant. # # Foo = 1 # ^^^^^^^ class ConstantWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader value: Prism::node attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :constant_write_node | ... def self.type: () -> :constant_write_node end # Represents a method definition. # # def method # end # ^^^^^^^^^^ class DefNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader receiver: Prism::node? attr_reader parameters: ParametersNode? attr_reader body: StatementsNode | BeginNode | nil attr_reader locals: Array[Symbol] attr_reader def_keyword_loc: Location attr_reader operator_loc: Location? attr_reader lparen_loc: Location? attr_reader rparen_loc: Location? attr_reader equal_loc: Location? attr_reader end_keyword_loc: Location? def save_name_loc: (_Repository repository) -> void def save_def_keyword_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def save_equal_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node? receiver, ParametersNode? parameters, StatementsNode | BeginNode | nil body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? } def def_keyword: () -> String def operator: () -> String? def lparen: () -> String? def rparen: () -> String? def equal: () -> String? def end_keyword: () -> String? def type: () -> :def_node | ... def self.type: () -> :def_node end # Represents the use of the `defined?` keyword. # # defined?(a) # ^^^^^^^^^^^ class DefinedNode < Node include _Node attr_reader lparen_loc: Location? attr_reader value: Prism::node attr_reader rparen_loc: Location? attr_reader keyword_loc: Location def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? lparen_loc, Prism::node value, Location? rparen_loc, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location } def lparen: () -> String? def rparen: () -> String? def keyword: () -> String def type: () -> :defined_node | ... def self.type: () -> :defined_node end # Represents an `else` clause in a `case`, `if`, or `unless` statement. # # if a then b else c end # ^^^^^^^^^^ class ElseNode < Node include _Node attr_reader else_keyword_loc: Location attr_reader statements: StatementsNode? attr_reader end_keyword_loc: Location? def save_else_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? } def else_keyword: () -> String def end_keyword: () -> String? def type: () -> :else_node | ... def self.type: () -> :else_node end # Represents an interpolated set of statements. # # "foo #{bar}" # ^^^^^^ class EmbeddedStatementsNode < Node include _Node attr_reader opening_loc: Location attr_reader statements: StatementsNode? attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, StatementsNode? statements, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :embedded_statements_node | ... def self.type: () -> :embedded_statements_node end # Represents an interpolated variable. # # "foo #@bar" # ^^^^^ class EmbeddedVariableNode < Node include _Node attr_reader operator_loc: Location attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode variable) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode } def operator: () -> String def type: () -> :embedded_variable_node | ... def self.type: () -> :embedded_variable_node end # Represents an `ensure` clause in a `begin` statement. # # begin # foo # ensure # ^^^^^^ # bar # end class EnsureNode < Node include _Node attr_reader ensure_keyword_loc: Location attr_reader statements: StatementsNode? attr_reader end_keyword_loc: Location def save_ensure_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location } def ensure_keyword: () -> String def end_keyword: () -> String def type: () -> :ensure_node | ... def self.type: () -> :ensure_node end # Represents the use of the literal `false` keyword. # # false # ^^^^^ class FalseNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :false_node | ... def self.type: () -> :false_node end # Represents a find pattern in pattern matching. # # foo in *bar, baz, *qux # ^^^^^^^^^^^^^^^ # # foo in [*bar, baz, *qux] # ^^^^^^^^^^^^^^^^^ # # foo in Foo(*bar, baz, *qux) # ^^^^^^^^^^^^^^^^^^^^ # # foo => *bar, baz, *qux # ^^^^^^^^^^^^^^^ class FindPatternNode < Node include _Node attr_reader constant: ConstantPathNode | ConstantReadNode | nil attr_reader left: SplatNode attr_reader requireds: Array[Prism::node] attr_reader right: SplatNode | MissingNode attr_reader opening_loc: Location? attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, SplatNode left, Array[Prism::node] requireds, SplatNode | MissingNode right, Location? opening_loc, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :find_pattern_node | ... def self.type: () -> :find_pattern_node end # Represents the use of the `..` or `...` operators to create flip flops. # # baz if foo .. bar # ^^^^^^^^^^ class FlipFlopNode < Node include _Node def exclude_end?: () -> bool attr_reader left: Prism::node? attr_reader right: Prism::node? attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location } def operator: () -> String def type: () -> :flip_flop_node | ... def self.type: () -> :flip_flop_node end # Represents a floating point number literal. # # 1.0 # ^^^ class FloatNode < Node include _Node attr_reader value: Float def initialize: (Source source, Integer node_id, Location location, Integer flags, Float value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float } def type: () -> :float_node | ... def self.type: () -> :float_node end # Represents the use of the `for` keyword. # # for i in a end # ^^^^^^^^^^^^^^ class ForNode < Node include _Node attr_reader index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode attr_reader collection: Prism::node attr_reader statements: StatementsNode? attr_reader for_keyword_loc: Location attr_reader in_keyword_loc: Location attr_reader do_keyword_loc: Location? attr_reader end_keyword_loc: Location def save_for_keyword_loc: (_Repository repository) -> void def save_in_keyword_loc: (_Repository repository) -> void def save_do_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode index, Prism::node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location } def for_keyword: () -> String def in_keyword: () -> String def do_keyword: () -> String? def end_keyword: () -> String def type: () -> :for_node | ... def self.type: () -> :for_node end # Represents forwarding all arguments to this method to another method. # # def foo(...) # bar(...) # ^^^ # end class ForwardingArgumentsNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :forwarding_arguments_node | ... def self.type: () -> :forwarding_arguments_node end # Represents the use of the forwarding parameter in a method, block, or lambda declaration. # # def foo(...) # ^^^ # end class ForwardingParameterNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :forwarding_parameter_node | ... def self.type: () -> :forwarding_parameter_node end # Represents the use of the `super` keyword without parentheses or arguments, but which might have a block. # # super # ^^^^^ # # super { 123 } # ^^^^^^^^^^^^^ # # If it has any other arguments, it would be a `SuperNode` instead. class ForwardingSuperNode < Node include _Node attr_reader block: BlockNode? def initialize: (Source source, Integer node_id, Location location, Integer flags, BlockNode? block) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? } def type: () -> :forwarding_super_node | ... def self.type: () -> :forwarding_super_node end # Represents the use of the `&&=` operator for assignment to a global variable. # # $target &&= value # ^^^^^^^^^^^^^^^^^ class GlobalVariableAndWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :global_variable_and_write_node | ... def self.type: () -> :global_variable_and_write_node end # Represents assigning to a global variable using an operator that isn't `=`. # # $target += value # ^^^^^^^^^^^^^^^^ class GlobalVariableOperatorWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader binary_operator: Symbol def save_name_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } def type: () -> :global_variable_operator_write_node | ... def self.type: () -> :global_variable_operator_write_node end # Represents the use of the `||=` operator for assignment to a global variable. # # $target ||= value # ^^^^^^^^^^^^^^^^^ class GlobalVariableOrWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :global_variable_or_write_node | ... def self.type: () -> :global_variable_or_write_node end # Represents referencing a global variable. # # $foo # ^^^^ class GlobalVariableReadNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :global_variable_read_node | ... def self.type: () -> :global_variable_read_node end # Represents writing to a global variable in a context that doesn't have an explicit value. # # $foo, $bar = baz # ^^^^ ^^^^ class GlobalVariableTargetNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :global_variable_target_node | ... def self.type: () -> :global_variable_target_node end # Represents writing to a global variable. # # $foo = 1 # ^^^^^^^^ class GlobalVariableWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader value: Prism::node attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :global_variable_write_node | ... def self.type: () -> :global_variable_write_node end # Represents a hash literal. # # { a => b } # ^^^^^^^^^^ class HashNode < Node include _Node attr_reader opening_loc: Location attr_reader elements: Array[AssocNode | AssocSplatNode] attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[AssocNode | AssocSplatNode] elements, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :hash_node | ... def self.type: () -> :hash_node end # Represents a hash pattern in pattern matching. # # foo => { a: 1, b: 2 } # ^^^^^^^^^^^^^^ # # foo => { a: 1, b: 2, **c } # ^^^^^^^^^^^^^^^^^^^ # # foo => Bar[a: 1, b: 2] # ^^^^^^^^^^^^^^^ # # foo in { a: 1, b: 2 } # ^^^^^^^^^^^^^^ class HashPatternNode < Node include _Node attr_reader constant: ConstantPathNode | ConstantReadNode | nil attr_reader elements: Array[AssocNode] attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil attr_reader opening_loc: Location? attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, Array[AssocNode] elements, AssocSplatNode | NoKeywordsParameterNode | nil rest, Location? opening_loc, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :hash_pattern_node | ... def self.type: () -> :hash_pattern_node end # Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression. # # bar if foo # ^^^^^^^^^^ # # if foo then bar end # ^^^^^^^^^^^^^^^^^^^ # # foo ? bar : baz # ^^^^^^^^^^^^^^^ class IfNode < Node include _Node attr_reader if_keyword_loc: Location? attr_reader predicate: Prism::node attr_reader then_keyword_loc: Location? attr_reader statements: StatementsNode? attr_reader subsequent: ElseNode | IfNode | nil attr_reader end_keyword_loc: Location? def save_if_keyword_loc: (_Repository repository) -> void def save_then_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode | IfNode | nil subsequent, Location? end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? } def if_keyword: () -> String? def then_keyword: () -> String? def end_keyword: () -> String? def type: () -> :if_node | ... def self.type: () -> :if_node end # Represents an imaginary number literal. # # 1.0i # ^^^^ class ImaginaryNode < Node include _Node attr_reader numeric: FloatNode | IntegerNode | RationalNode def initialize: (Source source, Integer node_id, Location location, Integer flags, FloatNode | IntegerNode | RationalNode numeric) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode } def type: () -> :imaginary_node | ... def self.type: () -> :imaginary_node end # Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source. # # { foo: } # ^^^^ # # { Foo: } # ^^^^ # # foo in { bar: } # ^^^^ class ImplicitNode < Node include _Node attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode } def type: () -> :implicit_node | ... def self.type: () -> :implicit_node end # Represents using a trailing comma to indicate an implicit rest parameter. # # foo { |bar,| } # ^ # # foo in [bar,] # ^ # # for foo, in bar do end # ^ # # foo, = bar # ^ class ImplicitRestNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :implicit_rest_node | ... def self.type: () -> :implicit_rest_node end # Represents the use of the `in` keyword in a case statement. # # case a; in b then c end # ^^^^^^^^^^^ class InNode < Node include _Node attr_reader pattern: Prism::node attr_reader statements: StatementsNode? attr_reader in_loc: Location attr_reader then_loc: Location? def save_in_loc: (_Repository repository) -> void def save_then_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? } def in: () -> String def then: () -> String? def type: () -> :in_node | ... def self.type: () -> :in_node end # Represents the use of the `&&=` operator on a call to the `[]` method. # # foo.bar[baz] &&= value # ^^^^^^^^^^^^^^^^^^^^^^ class IndexAndWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader opening_loc: Location attr_reader arguments: ArgumentsNode? attr_reader closing_loc: Location attr_reader block: BlockArgumentNode? attr_reader operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node } def call_operator: () -> String? def opening: () -> String def closing: () -> String def operator: () -> String def type: () -> :index_and_write_node | ... def self.type: () -> :index_and_write_node end # Represents the use of an assignment operator on a call to `[]`. # # foo.bar[baz] += value # ^^^^^^^^^^^^^^^^^^^^^ class IndexOperatorWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader opening_loc: Location attr_reader arguments: ArgumentsNode? attr_reader closing_loc: Location attr_reader block: BlockArgumentNode? attr_reader binary_operator: Symbol attr_reader binary_operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node } def call_operator: () -> String? def opening: () -> String def closing: () -> String def type: () -> :index_operator_write_node | ... def self.type: () -> :index_operator_write_node end # Represents the use of the `||=` operator on a call to `[]`. # # foo.bar[baz] ||= value # ^^^^^^^^^^^^^^^^^^^^^^ class IndexOrWriteNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node? attr_reader call_operator_loc: Location? attr_reader opening_loc: Location attr_reader arguments: ArgumentsNode? attr_reader closing_loc: Location attr_reader block: BlockArgumentNode? attr_reader operator_loc: Location attr_reader value: Prism::node def save_call_operator_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node } def call_operator: () -> String? def opening: () -> String def closing: () -> String def operator: () -> String def type: () -> :index_or_write_node | ... def self.type: () -> :index_or_write_node end # Represents assigning to an index. # # foo[bar], = 1 # ^^^^^^^^ # # begin # rescue => foo[bar] # ^^^^^^^^ # end # # for foo[bar] in baz do end # ^^^^^^^^ class IndexTargetNode < Node include _Node def safe_navigation?: () -> bool def variable_call?: () -> bool def attribute_write?: () -> bool def ignore_visibility?: () -> bool attr_reader receiver: Prism::node attr_reader opening_loc: Location attr_reader arguments: ArgumentsNode? attr_reader closing_loc: Location attr_reader block: BlockArgumentNode? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?) -> IndexTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? } def opening: () -> String def closing: () -> String def type: () -> :index_target_node | ... def self.type: () -> :index_target_node end # Represents the use of the `&&=` operator for assignment to an instance variable. # # @target &&= value # ^^^^^^^^^^^^^^^^^ class InstanceVariableAndWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :instance_variable_and_write_node | ... def self.type: () -> :instance_variable_and_write_node end # Represents assigning to an instance variable using an operator that isn't `=`. # # @target += value # ^^^^^^^^^^^^^^^^ class InstanceVariableOperatorWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader binary_operator: Symbol def save_name_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> InstanceVariableOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } def type: () -> :instance_variable_operator_write_node | ... def self.type: () -> :instance_variable_operator_write_node end # Represents the use of the `||=` operator for assignment to an instance variable. # # @target ||= value # ^^^^^^^^^^^^^^^^^ class InstanceVariableOrWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :instance_variable_or_write_node | ... def self.type: () -> :instance_variable_or_write_node end # Represents referencing an instance variable. # # @foo # ^^^^ class InstanceVariableReadNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :instance_variable_read_node | ... def self.type: () -> :instance_variable_read_node end # Represents writing to an instance variable in a context that doesn't have an explicit value. # # @foo, @bar = baz # ^^^^ ^^^^ class InstanceVariableTargetNode < Node include _Node attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :instance_variable_target_node | ... def self.type: () -> :instance_variable_target_node end # Represents writing to an instance variable. # # @foo = 1 # ^^^^^^^^ class InstanceVariableWriteNode < Node include _Node attr_reader name: Symbol attr_reader name_loc: Location attr_reader value: Prism::node attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> InstanceVariableWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :instance_variable_write_node | ... def self.type: () -> :instance_variable_write_node end # Represents an integer number literal. # # 1 # ^ class IntegerNode < Node include _Node def binary?: () -> bool def decimal?: () -> bool def octal?: () -> bool def hexadecimal?: () -> bool attr_reader value: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Integer) -> IntegerNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer } def type: () -> :integer_node | ... def self.type: () -> :integer_node end # Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object. # # if /foo #{bar} baz/ then end # ^^^^^^^^^^^^^^^^ class InterpolatedMatchLastLineNode < Node include _Node def ignore_case?: () -> bool def extended?: () -> bool def multi_line?: () -> bool def once?: () -> bool def euc_jp?: () -> bool def ascii_8bit?: () -> bool def windows_31j?: () -> bool def utf_8?: () -> bool def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def forced_us_ascii_encoding?: () -> bool attr_reader opening_loc: Location attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedMatchLastLineNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :interpolated_match_last_line_node | ... def self.type: () -> :interpolated_match_last_line_node end # Represents a regular expression literal that contains interpolation. # # /foo #{bar} baz/ # ^^^^^^^^^^^^^^^^ class InterpolatedRegularExpressionNode < Node include _Node def ignore_case?: () -> bool def extended?: () -> bool def multi_line?: () -> bool def once?: () -> bool def euc_jp?: () -> bool def ascii_8bit?: () -> bool def windows_31j?: () -> bool def utf_8?: () -> bool def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def forced_us_ascii_encoding?: () -> bool attr_reader opening_loc: Location attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedRegularExpressionNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :interpolated_regular_expression_node | ... def self.type: () -> :interpolated_regular_expression_node end # Represents a string literal that contains interpolation. # # "foo #{bar} baz" # ^^^^^^^^^^^^^^^^ class InterpolatedStringNode < Node include _Node def frozen?: () -> bool def mutable?: () -> bool attr_reader opening_loc: Location? attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode] attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode] parts, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], ?closing_loc: Location?) -> InterpolatedStringNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :interpolated_string_node | ... def self.type: () -> :interpolated_string_node end # Represents a symbol literal that contains interpolation. # # :"foo #{bar} baz" # ^^^^^^^^^^^^^^^^^ class InterpolatedSymbolNode < Node include _Node attr_reader opening_loc: Location? attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] attr_reader closing_loc: Location? def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location? closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?) -> InterpolatedSymbolNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? } def opening: () -> String? def closing: () -> String? def type: () -> :interpolated_symbol_node | ... def self.type: () -> :interpolated_symbol_node end # Represents an xstring literal that contains interpolation. # # `foo #{bar} baz` # ^^^^^^^^^^^^^^^^ class InterpolatedXStringNode < Node include _Node attr_reader opening_loc: Location attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedXStringNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :interpolated_x_string_node | ... def self.type: () -> :interpolated_x_string_node end # Represents reading from the implicit `it` local variable. # # -> { it } # ^^ class ItLocalVariableReadNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItLocalVariableReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :it_local_variable_read_node | ... def self.type: () -> :it_local_variable_read_node end # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda. # # -> { it + it } # ^^^^^^^^^^^^^^ class ItParametersNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItParametersNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :it_parameters_node | ... def self.type: () -> :it_parameters_node end # Represents a hash literal without opening and closing braces. # # foo(a: b) # ^^^^ class KeywordHashNode < Node include _Node def symbol_keys?: () -> bool attr_reader elements: Array[AssocNode | AssocSplatNode] def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[AssocNode | AssocSplatNode] elements) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode]) -> KeywordHashNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] } def type: () -> :keyword_hash_node | ... def self.type: () -> :keyword_hash_node end # Represents a keyword rest parameter to a method, block, or lambda definition. # # def a(**b) # ^^^ # end class KeywordRestParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol? attr_reader name_loc: Location? attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> KeywordRestParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } def operator: () -> String def type: () -> :keyword_rest_parameter_node | ... def self.type: () -> :keyword_rest_parameter_node end # Represents using a lambda literal (not the lambda method call). # # ->(value) { value * 2 } # ^^^^^^^^^^^^^^^^^^^^^^^ class LambdaNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader operator_loc: Location attr_reader opening_loc: Location attr_reader closing_loc: Location attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil attr_reader body: StatementsNode | BeginNode | nil def save_operator_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, BlockParametersNode | NumberedParametersNode | ItParametersNode | nil parameters, StatementsNode | BeginNode | nil body) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil) -> LambdaNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil } def operator: () -> String def opening: () -> String def closing: () -> String def type: () -> :lambda_node | ... def self.type: () -> :lambda_node end # Represents the use of the `&&=` operator for assignment to a local variable. # # target &&= value # ^^^^^^^^^^^^^^^^ class LocalVariableAndWriteNode < Node include _Node attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node attr_reader name: Symbol attr_reader depth: Integer def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableAndWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer } def operator: () -> String def type: () -> :local_variable_and_write_node | ... def self.type: () -> :local_variable_and_write_node end # Represents assigning to a local variable using an operator that isn't `=`. # # target += value # ^^^^^^^^^^^^^^^ class LocalVariableOperatorWriteNode < Node include _Node attr_reader name_loc: Location attr_reader binary_operator_loc: Location attr_reader value: Prism::node attr_reader name: Symbol attr_reader binary_operator: Symbol attr_reader depth: Integer def save_name_loc: (_Repository repository) -> void def save_binary_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer) -> LocalVariableOperatorWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer } def type: () -> :local_variable_operator_write_node | ... def self.type: () -> :local_variable_operator_write_node end # Represents the use of the `||=` operator for assignment to a local variable. # # target ||= value # ^^^^^^^^^^^^^^^^ class LocalVariableOrWriteNode < Node include _Node attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node attr_reader name: Symbol attr_reader depth: Integer def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableOrWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer } def operator: () -> String def type: () -> :local_variable_or_write_node | ... def self.type: () -> :local_variable_or_write_node end # Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call. # # foo # ^^^ class LocalVariableReadNode < Node include _Node attr_reader name: Symbol attr_reader depth: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer } def type: () -> :local_variable_read_node | ... def self.type: () -> :local_variable_read_node end # Represents writing to a local variable in a context that doesn't have an explicit value. # # foo, bar = baz # ^^^ ^^^ # # foo => baz # ^^^ class LocalVariableTargetNode < Node include _Node attr_reader name: Symbol attr_reader depth: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer } def type: () -> :local_variable_target_node | ... def self.type: () -> :local_variable_target_node end # Represents writing to a local variable. # # foo = 1 # ^^^^^^^ class LocalVariableWriteNode < Node include _Node attr_reader name: Symbol attr_reader depth: Integer attr_reader name_loc: Location attr_reader value: Prism::node attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth, Location name_loc, Prism::node value, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :local_variable_write_node | ... def self.type: () -> :local_variable_write_node end # Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object. # # if /foo/i then end # ^^^^^^ class MatchLastLineNode < Node include _Node def ignore_case?: () -> bool def extended?: () -> bool def multi_line?: () -> bool def once?: () -> bool def euc_jp?: () -> bool def ascii_8bit?: () -> bool def windows_31j?: () -> bool def utf_8?: () -> bool def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def forced_us_ascii_encoding?: () -> bool attr_reader opening_loc: Location attr_reader content_loc: Location attr_reader closing_loc: Location attr_reader unescaped: String def save_opening_loc: (_Repository repository) -> void def save_content_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> MatchLastLineNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } def opening: () -> String def content: () -> String def closing: () -> String def type: () -> :match_last_line_node | ... def self.type: () -> :match_last_line_node end # Represents the use of the modifier `in` operator. # # foo in bar # ^^^^^^^^^^ class MatchPredicateNode < Node include _Node attr_reader value: Prism::node attr_reader pattern: Prism::node attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :match_predicate_node | ... def self.type: () -> :match_predicate_node end # Represents the use of the `=>` operator. # # foo => bar # ^^^^^^^^^^ class MatchRequiredNode < Node include _Node attr_reader value: Prism::node attr_reader pattern: Prism::node attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchRequiredNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :match_required_node | ... def self.type: () -> :match_required_node end # Represents writing local variables using a regular expression match with named capture groups. # # /(?bar)/ =~ baz # ^^^^^^^^^^^^^^^^^^^^ class MatchWriteNode < Node include _Node attr_reader call: CallNode attr_reader targets: Array[LocalVariableTargetNode] def initialize: (Source source, Integer node_id, Location location, Integer flags, CallNode call, Array[LocalVariableTargetNode] targets) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?call: CallNode, ?targets: Array[LocalVariableTargetNode]) -> MatchWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] } def type: () -> :match_write_node | ... def self.type: () -> :match_write_node end # Represents a node that is missing from the source and results in a syntax error. class MissingNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> MissingNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :missing_node | ... def self.type: () -> :missing_node end # Represents a module declaration involving the `module` keyword. # # module Foo end # ^^^^^^^^^^^^^^ class ModuleNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader module_keyword_loc: Location attr_reader constant_path: ConstantReadNode | ConstantPathNode | MissingNode attr_reader body: StatementsNode | BeginNode | nil attr_reader end_keyword_loc: Location attr_reader name: Symbol def save_module_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location module_keyword_loc, ConstantReadNode | ConstantPathNode | MissingNode constant_path, StatementsNode | BeginNode | nil body, Location end_keyword_loc, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | MissingNode, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol } def module_keyword: () -> String def end_keyword: () -> String def type: () -> :module_node | ... def self.type: () -> :module_node end # Represents a multi-target expression. # # a, (b, c) = 1, 2, 3 # ^^^^^^ # # This can be a part of `MultiWriteNode` as above, or the target of a `for` loop # # for a, b in [[1, 2], [3, 4]] # ^^^^ class MultiTargetNode < Node include _Node attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] attr_reader rest: ImplicitRestNode | SplatNode | nil attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] attr_reader lparen_loc: Location? attr_reader rparen_loc: Location? def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, ImplicitRestNode | SplatNode | nil rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? } def lparen: () -> String? def rparen: () -> String? def type: () -> :multi_target_node | ... def self.type: () -> :multi_target_node end # Represents a write to a multi-target expression. # # a, b, c = 1, 2, 3 # ^^^^^^^^^^^^^^^^^ class MultiWriteNode < Node include _Node attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] attr_reader rest: ImplicitRestNode | SplatNode | nil attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] attr_reader lparen_loc: Location? attr_reader rparen_loc: Location? attr_reader operator_loc: Location attr_reader value: Prism::node def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, ImplicitRestNode | SplatNode | nil rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node } def lparen: () -> String? def rparen: () -> String? def operator: () -> String def type: () -> :multi_write_node | ... def self.type: () -> :multi_write_node end # Represents the use of the `next` keyword. # # next 1 # ^^^^^^ class NextNode < Node include _Node attr_reader arguments: ArgumentsNode? attr_reader keyword_loc: Location def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, ArgumentsNode? arguments, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> NextNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location } def keyword: () -> String def type: () -> :next_node | ... def self.type: () -> :next_node end # Represents the use of the `nil` keyword. # # nil # ^^^ class NilNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> NilNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :nil_node | ... def self.type: () -> :nil_node end # Represents the use of `**nil` inside method arguments. # # def a(**nil) # ^^^^^ # end class NoKeywordsParameterNode < Node include _Node attr_reader operator_loc: Location attr_reader keyword_loc: Location def save_operator_loc: (_Repository repository) -> void def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?keyword_loc: Location) -> NoKeywordsParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location } def operator: () -> String def keyword: () -> String def type: () -> :no_keywords_parameter_node | ... def self.type: () -> :no_keywords_parameter_node end # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda. # # -> { _1 + _2 } # ^^^^^^^^^^^^^^ class NumberedParametersNode < Node include _Node attr_reader maximum: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer maximum) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?maximum: Integer) -> NumberedParametersNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer } def type: () -> :numbered_parameters_node | ... def self.type: () -> :numbered_parameters_node end # Represents reading a numbered reference to a capture in the previous match. # # $1 # ^^ class NumberedReferenceReadNode < Node include _Node attr_reader number: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer number) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?number: Integer) -> NumberedReferenceReadNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer } def type: () -> :numbered_reference_read_node | ... def self.type: () -> :numbered_reference_read_node end # Represents an optional keyword parameter to a method, block, or lambda definition. # # def a(b: 1) # ^^^^ # end class OptionalKeywordParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol attr_reader name_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node) -> OptionalKeywordParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node } def type: () -> :optional_keyword_parameter_node | ... def self.type: () -> :optional_keyword_parameter_node end # Represents an optional parameter to a method, block, or lambda definition. # # def a(b = 1) # ^^^^^ # end class OptionalParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol attr_reader name_loc: Location attr_reader operator_loc: Location attr_reader value: Prism::node def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> OptionalParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } def operator: () -> String def type: () -> :optional_parameter_node | ... def self.type: () -> :optional_parameter_node end # Represents the use of the `||` operator or the `or` keyword. # # left or right # ^^^^^^^^^^^^^ class OrNode < Node include _Node attr_reader left: Prism::node attr_reader right: Prism::node attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> OrNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } def operator: () -> String def type: () -> :or_node | ... def self.type: () -> :or_node end # Represents the list of parameters on a method, block, or lambda definition. # # def a(b, c, d) # ^^^^^^^ # end class ParametersNode < Node include _Node attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode] attr_reader optionals: Array[OptionalParameterNode] attr_reader rest: RestParameterNode | ImplicitRestNode | nil attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil attr_reader block: BlockParameterNode? def initialize: (Source source, Integer node_id, Location location, Integer flags, 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) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? } def type: () -> :parameters_node | ... def self.type: () -> :parameters_node end # Represents a parenthesized expression # # (10 + 34) # ^^^^^^^^^ class ParenthesesNode < Node include _Node def multiple_statements?: () -> bool attr_reader body: Prism::node? attr_reader opening_loc: Location attr_reader closing_loc: Location def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? body, Location opening_loc, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location) -> ParenthesesNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location } def opening: () -> String def closing: () -> String def type: () -> :parentheses_node | ... def self.type: () -> :parentheses_node end # Represents the use of the `^` operator for pinning an expression in a pattern matching expression. # # foo in ^(bar) # ^^^^^^ class PinnedExpressionNode < Node include _Node attr_reader expression: Prism::node attr_reader operator_loc: Location attr_reader lparen_loc: Location attr_reader rparen_loc: Location def save_operator_loc: (_Repository repository) -> void def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node expression, Location operator_loc, Location lparen_loc, Location rparen_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location) -> PinnedExpressionNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location } def operator: () -> String def lparen: () -> String def rparen: () -> String def type: () -> :pinned_expression_node | ... def self.type: () -> :pinned_expression_node end # Represents the use of the `^` operator for pinning a variable in a pattern matching expression. # # foo in ^bar # ^^^^ class PinnedVariableNode < Node include _Node attr_reader variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode variable, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, ?operator_loc: Location) -> PinnedVariableNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location } def operator: () -> String def type: () -> :pinned_variable_node | ... def self.type: () -> :pinned_variable_node end # Represents the use of the `END` keyword. # # END { foo } # ^^^^^^^^^^^ class PostExecutionNode < Node include _Node attr_reader statements: StatementsNode? attr_reader keyword_loc: Location attr_reader opening_loc: Location attr_reader closing_loc: Location def save_keyword_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PostExecutionNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location } def keyword: () -> String def opening: () -> String def closing: () -> String def type: () -> :post_execution_node | ... def self.type: () -> :post_execution_node end # Represents the use of the `BEGIN` keyword. # # BEGIN { foo } # ^^^^^^^^^^^^^ class PreExecutionNode < Node include _Node attr_reader statements: StatementsNode? attr_reader keyword_loc: Location attr_reader opening_loc: Location attr_reader closing_loc: Location def save_keyword_loc: (_Repository repository) -> void def save_opening_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PreExecutionNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location } def keyword: () -> String def opening: () -> String def closing: () -> String def type: () -> :pre_execution_node | ... def self.type: () -> :pre_execution_node end # The top level node of any parse tree. class ProgramNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader statements: StatementsNode def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, StatementsNode statements) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?statements: StatementsNode) -> ProgramNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode } def type: () -> :program_node | ... def self.type: () -> :program_node end # Represents the use of the `..` or `...` operators. # # 1..2 # ^^^^ # # c if a =~ /left/ ... b =~ /right/ # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ class RangeNode < Node include _Node def exclude_end?: () -> bool attr_reader left: Prism::node? attr_reader right: Prism::node? attr_reader operator_loc: Location def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> RangeNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location } def operator: () -> String def type: () -> :range_node | ... def self.type: () -> :range_node end # Represents a rational number literal. # # 1.0r # ^^^^ class RationalNode < Node include _Node def binary?: () -> bool def decimal?: () -> bool def octal?: () -> bool def hexadecimal?: () -> bool attr_reader numerator: Integer attr_reader denominator: Integer def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer numerator, Integer denominator) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numerator: Integer, ?denominator: Integer) -> RationalNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer } def type: () -> :rational_node | ... def self.type: () -> :rational_node end # Represents the use of the `redo` keyword. # # redo # ^^^^ class RedoNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RedoNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :redo_node | ... def self.type: () -> :redo_node end # Represents a regular expression literal with no interpolation. # # /foo/i # ^^^^^^ class RegularExpressionNode < Node include _Node def ignore_case?: () -> bool def extended?: () -> bool def multi_line?: () -> bool def once?: () -> bool def euc_jp?: () -> bool def ascii_8bit?: () -> bool def windows_31j?: () -> bool def utf_8?: () -> bool def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def forced_us_ascii_encoding?: () -> bool attr_reader opening_loc: Location attr_reader content_loc: Location attr_reader closing_loc: Location attr_reader unescaped: String def save_opening_loc: (_Repository repository) -> void def save_content_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } def opening: () -> String def content: () -> String def closing: () -> String def type: () -> :regular_expression_node | ... def self.type: () -> :regular_expression_node end # Represents a required keyword parameter to a method, block, or lambda definition. # # def a(b: ) # ^^ # end class RequiredKeywordParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol attr_reader name_loc: Location def save_name_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location) -> RequiredKeywordParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location } def type: () -> :required_keyword_parameter_node | ... def self.type: () -> :required_keyword_parameter_node end # Represents a required parameter to a method, block, or lambda definition. # # def a(b) # ^ # end class RequiredParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> RequiredParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } def type: () -> :required_parameter_node | ... def self.type: () -> :required_parameter_node end # Represents an expression modified with a rescue. # # foo rescue nil # ^^^^^^^^^^^^^^ class RescueModifierNode < Node include _Node attr_reader expression: Prism::node attr_reader keyword_loc: Location attr_reader rescue_expression: Prism::node def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node expression, Location keyword_loc, Prism::node rescue_expression) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node) -> RescueModifierNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node } def keyword: () -> String def type: () -> :rescue_modifier_node | ... def self.type: () -> :rescue_modifier_node 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 `reference` field. class RescueNode < Node include _Node attr_reader keyword_loc: Location attr_reader exceptions: Array[Prism::node] attr_reader operator_loc: Location? attr_reader reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil attr_reader then_keyword_loc: Location? attr_reader statements: StatementsNode? attr_reader subsequent: RescueNode? def save_keyword_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def save_then_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] exceptions, Location? operator_loc, LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil reference, Location? then_keyword_loc, StatementsNode? statements, RescueNode? subsequent) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: RescueNode? } def keyword: () -> String def operator: () -> String? def then_keyword: () -> String? def type: () -> :rescue_node | ... def self.type: () -> :rescue_node end # Represents a rest parameter to a method, block, or lambda definition. # # def a(*b) # ^^ # end class RestParameterNode < Node include _Node def repeated_parameter?: () -> bool attr_reader name: Symbol? attr_reader name_loc: Location? attr_reader operator_loc: Location def save_name_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> RestParameterNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } def operator: () -> String def type: () -> :rest_parameter_node | ... def self.type: () -> :rest_parameter_node end # Represents the use of the `retry` keyword. # # retry # ^^^^^ class RetryNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RetryNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :retry_node | ... def self.type: () -> :retry_node end # Represents the use of the `return` keyword. # # return 1 # ^^^^^^^^ class ReturnNode < Node include _Node attr_reader keyword_loc: Location attr_reader arguments: ArgumentsNode? def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, ArgumentsNode? arguments) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?) -> ReturnNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? } def keyword: () -> String def type: () -> :return_node | ... def self.type: () -> :return_node end # Represents the `self` keyword. # # self # ^^^^ class SelfNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SelfNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :self_node | ... def self.type: () -> :self_node end # This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified. # # # shareable_constant_value: literal # C = { a: 1 } # ^^^^^^^^^^^^ class ShareableConstantNode < Node include _Node def literal?: () -> bool def experimental_everything?: () -> bool def experimental_copy?: () -> bool attr_reader write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode write) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode) -> ShareableConstantNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode } def type: () -> :shareable_constant_node | ... def self.type: () -> :shareable_constant_node end # Represents a singleton class declaration involving the `class` keyword. # # class << self end # ^^^^^^^^^^^^^^^^^ class SingletonClassNode < Node include _Node attr_reader locals: Array[Symbol] attr_reader class_keyword_loc: Location attr_reader operator_loc: Location attr_reader expression: Prism::node attr_reader body: StatementsNode | BeginNode | nil attr_reader end_keyword_loc: Location def save_class_keyword_loc: (_Repository repository) -> void def save_operator_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Prism::node expression, StatementsNode | BeginNode | nil body, Location end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location) -> SingletonClassNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location } def class_keyword: () -> String def operator: () -> String def end_keyword: () -> String def type: () -> :singleton_class_node | ... def self.type: () -> :singleton_class_node end # Represents the use of the `__ENCODING__` keyword. # # __ENCODING__ # ^^^^^^^^^^^^ class SourceEncodingNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceEncodingNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :source_encoding_node | ... def self.type: () -> :source_encoding_node end # Represents the use of the `__FILE__` keyword. # # __FILE__ # ^^^^^^^^ class SourceFileNode < Node include _Node def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def frozen?: () -> bool def mutable?: () -> bool attr_reader filepath: String def initialize: (Source source, Integer node_id, Location location, Integer flags, String filepath) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?filepath: String) -> SourceFileNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String } def type: () -> :source_file_node | ... def self.type: () -> :source_file_node end # Represents the use of the `__LINE__` keyword. # # __LINE__ # ^^^^^^^^ class SourceLineNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceLineNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :source_line_node | ... def self.type: () -> :source_line_node end # Represents the use of the splat operator. # # [*a] # ^^ class SplatNode < Node include _Node attr_reader operator_loc: Location attr_reader expression: Prism::node? def save_operator_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, Prism::node? expression) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?expression: Prism::node?) -> SplatNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? } def operator: () -> String def type: () -> :splat_node | ... def self.type: () -> :splat_node end # Represents a set of statements contained within some scope. # # foo; bar; baz # ^^^^^^^^^^^^^ class StatementsNode < Node include _Node attr_reader body: Array[Prism::node] def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] body) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Array[Prism::node]) -> StatementsNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] } def type: () -> :statements_node | ... def self.type: () -> :statements_node end # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string. # # "foo" # ^^^^^ # # %w[foo] # ^^^ # # "foo #{bar} baz" # ^^^^ ^^^^ class StringNode < Node include _Node def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def frozen?: () -> bool def mutable?: () -> bool attr_reader opening_loc: Location? attr_reader content_loc: Location attr_reader closing_loc: Location? attr_reader unescaped: String def save_opening_loc: (_Repository repository) -> void def save_content_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String) -> StringNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String } def opening: () -> String? def content: () -> String def closing: () -> String? def type: () -> :string_node | ... def self.type: () -> :string_node end # Represents the use of the `super` keyword with parentheses or arguments. # # super() # ^^^^^^^ # # super foo, bar # ^^^^^^^^^^^^^^ # # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead. class SuperNode < Node include _Node attr_reader keyword_loc: Location attr_reader lparen_loc: Location? attr_reader arguments: ArgumentsNode? attr_reader rparen_loc: Location? attr_reader block: BlockNode | BlockArgumentNode | nil def save_keyword_loc: (_Repository repository) -> void def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, BlockNode | BlockArgumentNode | nil block) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> SuperNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil } def keyword: () -> String def lparen: () -> String? def rparen: () -> String? def type: () -> :super_node | ... def self.type: () -> :super_node end # Represents a symbol literal or a symbol contained within a `%i` list. # # :foo # ^^^^ # # %i[foo] # ^^^ class SymbolNode < Node include _Node def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool def forced_us_ascii_encoding?: () -> bool attr_reader opening_loc: Location? attr_reader value_loc: Location? attr_reader closing_loc: Location? attr_reader unescaped: String def save_opening_loc: (_Repository repository) -> void def save_value_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String) -> SymbolNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String } def opening: () -> String? def value: () -> String? def closing: () -> String? def type: () -> :symbol_node | ... def self.type: () -> :symbol_node end # Represents the use of the literal `true` keyword. # # true # ^^^^ class TrueNode < Node include _Node def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> TrueNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } def type: () -> :true_node | ... def self.type: () -> :true_node end # Represents the use of the `undef` keyword. # # undef :foo, :bar, :baz # ^^^^^^^^^^^^^^^^^^^^^^ class UndefNode < Node include _Node attr_reader names: Array[SymbolNode | InterpolatedSymbolNode] attr_reader keyword_loc: Location def save_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[SymbolNode | InterpolatedSymbolNode] names, Location keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location) -> UndefNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location } def keyword: () -> String def type: () -> :undef_node | ... def self.type: () -> :undef_node end # Represents the use of the `unless` keyword, either in the block form or the modifier form. # # bar unless foo # ^^^^^^^^^^^^^^ # # unless foo then bar end # ^^^^^^^^^^^^^^^^^^^^^^^ class UnlessNode < Node include _Node attr_reader keyword_loc: Location attr_reader predicate: Prism::node attr_reader then_keyword_loc: Location? attr_reader statements: StatementsNode? attr_reader else_clause: ElseNode? attr_reader end_keyword_loc: Location? def save_keyword_loc: (_Repository repository) -> void def save_then_keyword_loc: (_Repository repository) -> void def save_end_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? } def keyword: () -> String def then_keyword: () -> String? def end_keyword: () -> String? def type: () -> :unless_node | ... def self.type: () -> :unless_node end # Represents the use of the `until` keyword, either in the block form or the modifier form. # # bar until foo # ^^^^^^^^^^^^^ # # until foo do bar end # ^^^^^^^^^^^^^^^^^^^^ class UntilNode < Node include _Node def begin_modifier?: () -> bool attr_reader keyword_loc: Location attr_reader do_keyword_loc: Location? attr_reader closing_loc: Location? attr_reader predicate: Prism::node attr_reader statements: StatementsNode? def save_keyword_loc: (_Repository repository) -> void def save_do_keyword_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? } def keyword: () -> String def do_keyword: () -> String? def closing: () -> String? def type: () -> :until_node | ... def self.type: () -> :until_node end # Represents the use of the `when` keyword within a case statement. # # case true # when true # ^^^^^^^^^ # end class WhenNode < Node include _Node attr_reader keyword_loc: Location attr_reader conditions: Array[Prism::node] attr_reader then_keyword_loc: Location? attr_reader statements: StatementsNode? def save_keyword_loc: (_Repository repository) -> void def save_then_keyword_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? } def keyword: () -> String def then_keyword: () -> String? def type: () -> :when_node | ... def self.type: () -> :when_node end # Represents the use of the `while` keyword, either in the block form or the modifier form. # # bar while foo # ^^^^^^^^^^^^^ # # while foo do bar end # ^^^^^^^^^^^^^^^^^^^^ class WhileNode < Node include _Node def begin_modifier?: () -> bool attr_reader keyword_loc: Location attr_reader do_keyword_loc: Location? attr_reader closing_loc: Location? attr_reader predicate: Prism::node attr_reader statements: StatementsNode? def save_keyword_loc: (_Repository repository) -> void def save_do_keyword_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? } def keyword: () -> String def do_keyword: () -> String? def closing: () -> String? def type: () -> :while_node | ... def self.type: () -> :while_node end # Represents an xstring literal with no interpolation. # # `foo` # ^^^^^ class XStringNode < Node include _Node def forced_utf8_encoding?: () -> bool def forced_binary_encoding?: () -> bool attr_reader opening_loc: Location attr_reader content_loc: Location attr_reader closing_loc: Location attr_reader unescaped: String def save_opening_loc: (_Repository repository) -> void def save_content_loc: (_Repository repository) -> void def save_closing_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } def opening: () -> String def content: () -> String def closing: () -> String def type: () -> :x_string_node | ... def self.type: () -> :x_string_node end # Represents the use of the `yield` keyword. # # yield 1 # ^^^^^^^ class YieldNode < Node include _Node attr_reader keyword_loc: Location attr_reader lparen_loc: Location? attr_reader arguments: ArgumentsNode? attr_reader rparen_loc: Location? def save_keyword_loc: (_Repository repository) -> void def save_lparen_loc: (_Repository repository) -> void def save_rparen_loc: (_Repository repository) -> void def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc) -> void def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?) -> YieldNode def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? } def keyword: () -> String def lparen: () -> String? def rparen: () -> String? def type: () -> :yield_node | ... def self.type: () -> :yield_node end # Flags for arguments nodes. module ArgumentsNodeFlags # if the arguments contain forwarding CONTAINS_FORWARDING: Integer # if the arguments contain keywords CONTAINS_KEYWORDS: Integer # if the arguments contain a keyword splat CONTAINS_KEYWORD_SPLAT: Integer # if the arguments contain a splat CONTAINS_SPLAT: Integer # if the arguments contain multiple splats CONTAINS_MULTIPLE_SPLATS: Integer end # Flags for array nodes. module ArrayNodeFlags # if array contains splat nodes CONTAINS_SPLAT: Integer end # Flags for call nodes. module CallNodeFlags # &. operator SAFE_NAVIGATION: Integer # a call that could have been a local variable VARIABLE_CALL: Integer # a call that is an attribute write, so the value being written should be returned ATTRIBUTE_WRITE: Integer # a call that ignores method visibility IGNORE_VISIBILITY: Integer end # Flags for nodes that have unescaped content. module EncodingFlags # internal bytes forced the encoding to UTF-8 FORCED_UTF8_ENCODING: Integer # internal bytes forced the encoding to binary FORCED_BINARY_ENCODING: Integer end # Flags for integer nodes that correspond to the base of the integer. module IntegerBaseFlags # 0b prefix BINARY: Integer # 0d or no prefix DECIMAL: Integer # 0o or 0 prefix OCTAL: Integer # 0x prefix HEXADECIMAL: Integer end # Flags for interpolated string nodes that indicated mutability if they are also marked as literals. module InterpolatedStringNodeFlags # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` FROZEN: Integer # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` MUTABLE: Integer end # Flags for keyword hash nodes. module KeywordHashNodeFlags # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments SYMBOL_KEYS: Integer end # Flags for while and until loop nodes. module LoopFlags # a loop after a begin statement, so the body is executed first before the condition BEGIN_MODIFIER: Integer end # Flags for parameter nodes. module ParameterFlags # a parameter name that has been repeated in the method signature REPEATED_PARAMETER: Integer end # Flags for parentheses nodes. module ParenthesesNodeFlags # parentheses that contain multiple potentially void statements MULTIPLE_STATEMENTS: Integer end # Flags for range and flip-flop nodes. module RangeFlags # ... operator EXCLUDE_END: Integer end # Flags for regular expression and match last line nodes. module RegularExpressionFlags # i - ignores the case of characters when matching IGNORE_CASE: Integer # x - ignores whitespace and allows comments in regular expressions EXTENDED: Integer # m - allows $ to match the end of lines within strings MULTI_LINE: Integer # o - only interpolates values into the regular expression once ONCE: Integer # e - forces the EUC-JP encoding EUC_JP: Integer # n - forces the ASCII-8BIT encoding ASCII_8BIT: Integer # s - forces the Windows-31J encoding WINDOWS_31J: Integer # u - forces the UTF-8 encoding UTF_8: Integer # internal bytes forced the encoding to UTF-8 FORCED_UTF8_ENCODING: Integer # internal bytes forced the encoding to binary FORCED_BINARY_ENCODING: Integer # internal bytes forced the encoding to US-ASCII FORCED_US_ASCII_ENCODING: Integer end # Flags for shareable constant nodes. module ShareableConstantNodeFlags # constant writes that should be modified with shareable constant value literal LITERAL: Integer # constant writes that should be modified with shareable constant value experimental everything EXPERIMENTAL_EVERYTHING: Integer # constant writes that should be modified with shareable constant value experimental copy EXPERIMENTAL_COPY: Integer end # Flags for string nodes. module StringFlags # internal bytes forced the encoding to UTF-8 FORCED_UTF8_ENCODING: Integer # internal bytes forced the encoding to binary FORCED_BINARY_ENCODING: Integer # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` FROZEN: Integer # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` MUTABLE: Integer end # Flags for symbol nodes. module SymbolFlags # internal bytes forced the encoding to UTF-8 FORCED_UTF8_ENCODING: Integer # internal bytes forced the encoding to binary FORCED_BINARY_ENCODING: Integer # internal bytes forced the encoding to US-ASCII FORCED_US_ASCII_ENCODING: Integer end # The flags that are common to all nodes. module NodeFlags NEWLINE: Integer STATIC_LITERAL: Integer end end