File: //opt/cpanel/ea-ruby27/root/usr/local/share/gems/gems/prism-1.9.0/include/prism/ast.h
/* :markup: markdown */
/*----------------------------------------------------------------------------*/
/* This file is generated by the templates/template.rb script and should not */
/* be modified manually. See */
/* templates/include/prism/ast.h.erb */
/* if you are looking to modify the */
/* template */
/*----------------------------------------------------------------------------*/
/**
* @file ast.h
*
* The abstract syntax tree.
*
* --
*/
#ifndef PRISM_AST_H
#define PRISM_AST_H
#include "prism/defines.h"
#include "prism/util/pm_constant_pool.h"
#include "prism/util/pm_integer.h"
#include "prism/util/pm_string.h"
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
/**
* This enum represents every type of token in the Ruby source.
*/
typedef enum pm_token_type {
/** final token in the file */
PM_TOKEN_EOF = 1,
/** } */
PM_TOKEN_BRACE_RIGHT,
/** , */
PM_TOKEN_COMMA,
/** } */
PM_TOKEN_EMBEXPR_END,
/** do */
PM_TOKEN_KEYWORD_DO,
/** else */
PM_TOKEN_KEYWORD_ELSE,
/** elsif */
PM_TOKEN_KEYWORD_ELSIF,
/** end */
PM_TOKEN_KEYWORD_END,
/** ensure */
PM_TOKEN_KEYWORD_ENSURE,
/** in */
PM_TOKEN_KEYWORD_IN,
/** rescue */
PM_TOKEN_KEYWORD_RESCUE,
/** then */
PM_TOKEN_KEYWORD_THEN,
/** when */
PM_TOKEN_KEYWORD_WHEN,
/** a newline character outside of other tokens */
PM_TOKEN_NEWLINE,
/** ) */
PM_TOKEN_PARENTHESIS_RIGHT,
/** | */
PM_TOKEN_PIPE,
/** ; */
PM_TOKEN_SEMICOLON,
/** & */
PM_TOKEN_AMPERSAND,
/** && */
PM_TOKEN_AMPERSAND_AMPERSAND,
/** &&= */
PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL,
/** &. */
PM_TOKEN_AMPERSAND_DOT,
/** &= */
PM_TOKEN_AMPERSAND_EQUAL,
/** ` */
PM_TOKEN_BACKTICK,
/** a back reference */
PM_TOKEN_BACK_REFERENCE,
/** ! or !@ */
PM_TOKEN_BANG,
/** != */
PM_TOKEN_BANG_EQUAL,
/** !~ */
PM_TOKEN_BANG_TILDE,
/** { */
PM_TOKEN_BRACE_LEFT,
/** [ */
PM_TOKEN_BRACKET_LEFT,
/** [ for the beginning of an array */
PM_TOKEN_BRACKET_LEFT_ARRAY,
/** [] */
PM_TOKEN_BRACKET_LEFT_RIGHT,
/** []= */
PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL,
/** ] */
PM_TOKEN_BRACKET_RIGHT,
/** ^ */
PM_TOKEN_CARET,
/** ^= */
PM_TOKEN_CARET_EQUAL,
/** a character literal */
PM_TOKEN_CHARACTER_LITERAL,
/** a class variable */
PM_TOKEN_CLASS_VARIABLE,
/** : */
PM_TOKEN_COLON,
/** :: */
PM_TOKEN_COLON_COLON,
/** a comment */
PM_TOKEN_COMMENT,
/** a constant */
PM_TOKEN_CONSTANT,
/** the . call operator */
PM_TOKEN_DOT,
/** the .. range operator */
PM_TOKEN_DOT_DOT,
/** the ... range operator or forwarding parameter */
PM_TOKEN_DOT_DOT_DOT,
/** =begin */
PM_TOKEN_EMBDOC_BEGIN,
/** =end */
PM_TOKEN_EMBDOC_END,
/** a line inside of embedded documentation */
PM_TOKEN_EMBDOC_LINE,
/** #{ */
PM_TOKEN_EMBEXPR_BEGIN,
/** # */
PM_TOKEN_EMBVAR,
/** = */
PM_TOKEN_EQUAL,
/** == */
PM_TOKEN_EQUAL_EQUAL,
/** === */
PM_TOKEN_EQUAL_EQUAL_EQUAL,
/** => */
PM_TOKEN_EQUAL_GREATER,
/** =~ */
PM_TOKEN_EQUAL_TILDE,
/** a floating point number */
PM_TOKEN_FLOAT,
/** a floating pointer number with an imaginary suffix */
PM_TOKEN_FLOAT_IMAGINARY,
/** a floating pointer number with a rational suffix */
PM_TOKEN_FLOAT_RATIONAL,
/** a floating pointer number with a rational and imaginary suffix */
PM_TOKEN_FLOAT_RATIONAL_IMAGINARY,
/** a global variable */
PM_TOKEN_GLOBAL_VARIABLE,
/** > */
PM_TOKEN_GREATER,
/** >= */
PM_TOKEN_GREATER_EQUAL,
/** >> */
PM_TOKEN_GREATER_GREATER,
/** >>= */
PM_TOKEN_GREATER_GREATER_EQUAL,
/** the end of a heredoc */
PM_TOKEN_HEREDOC_END,
/** the start of a heredoc */
PM_TOKEN_HEREDOC_START,
/** an identifier */
PM_TOKEN_IDENTIFIER,
/** an ignored newline */
PM_TOKEN_IGNORED_NEWLINE,
/** an instance variable */
PM_TOKEN_INSTANCE_VARIABLE,
/** an integer (any base) */
PM_TOKEN_INTEGER,
/** an integer with an imaginary suffix */
PM_TOKEN_INTEGER_IMAGINARY,
/** an integer with a rational suffix */
PM_TOKEN_INTEGER_RATIONAL,
/** an integer with a rational and imaginary suffix */
PM_TOKEN_INTEGER_RATIONAL_IMAGINARY,
/** alias */
PM_TOKEN_KEYWORD_ALIAS,
/** and */
PM_TOKEN_KEYWORD_AND,
/** begin */
PM_TOKEN_KEYWORD_BEGIN,
/** BEGIN */
PM_TOKEN_KEYWORD_BEGIN_UPCASE,
/** break */
PM_TOKEN_KEYWORD_BREAK,
/** case */
PM_TOKEN_KEYWORD_CASE,
/** class */
PM_TOKEN_KEYWORD_CLASS,
/** def */
PM_TOKEN_KEYWORD_DEF,
/** defined? */
PM_TOKEN_KEYWORD_DEFINED,
/** do keyword for a predicate in a while, until, or for loop */
PM_TOKEN_KEYWORD_DO_LOOP,
/** END */
PM_TOKEN_KEYWORD_END_UPCASE,
/** false */
PM_TOKEN_KEYWORD_FALSE,
/** for */
PM_TOKEN_KEYWORD_FOR,
/** if */
PM_TOKEN_KEYWORD_IF,
/** if in the modifier form */
PM_TOKEN_KEYWORD_IF_MODIFIER,
/** module */
PM_TOKEN_KEYWORD_MODULE,
/** next */
PM_TOKEN_KEYWORD_NEXT,
/** nil */
PM_TOKEN_KEYWORD_NIL,
/** not */
PM_TOKEN_KEYWORD_NOT,
/** or */
PM_TOKEN_KEYWORD_OR,
/** redo */
PM_TOKEN_KEYWORD_REDO,
/** rescue in the modifier form */
PM_TOKEN_KEYWORD_RESCUE_MODIFIER,
/** retry */
PM_TOKEN_KEYWORD_RETRY,
/** return */
PM_TOKEN_KEYWORD_RETURN,
/** self */
PM_TOKEN_KEYWORD_SELF,
/** super */
PM_TOKEN_KEYWORD_SUPER,
/** true */
PM_TOKEN_KEYWORD_TRUE,
/** undef */
PM_TOKEN_KEYWORD_UNDEF,
/** unless */
PM_TOKEN_KEYWORD_UNLESS,
/** unless in the modifier form */
PM_TOKEN_KEYWORD_UNLESS_MODIFIER,
/** until */
PM_TOKEN_KEYWORD_UNTIL,
/** until in the modifier form */
PM_TOKEN_KEYWORD_UNTIL_MODIFIER,
/** while */
PM_TOKEN_KEYWORD_WHILE,
/** while in the modifier form */
PM_TOKEN_KEYWORD_WHILE_MODIFIER,
/** yield */
PM_TOKEN_KEYWORD_YIELD,
/** __ENCODING__ */
PM_TOKEN_KEYWORD___ENCODING__,
/** __FILE__ */
PM_TOKEN_KEYWORD___FILE__,
/** __LINE__ */
PM_TOKEN_KEYWORD___LINE__,
/** a label */
PM_TOKEN_LABEL,
/** the end of a label */
PM_TOKEN_LABEL_END,
/** { */
PM_TOKEN_LAMBDA_BEGIN,
/** < */
PM_TOKEN_LESS,
/** <= */
PM_TOKEN_LESS_EQUAL,
/** <=> */
PM_TOKEN_LESS_EQUAL_GREATER,
/** << */
PM_TOKEN_LESS_LESS,
/** <<= */
PM_TOKEN_LESS_LESS_EQUAL,
/** a method name */
PM_TOKEN_METHOD_NAME,
/** - */
PM_TOKEN_MINUS,
/** -= */
PM_TOKEN_MINUS_EQUAL,
/** -> */
PM_TOKEN_MINUS_GREATER,
/** a numbered reference to a capture group in the previous regular expression match */
PM_TOKEN_NUMBERED_REFERENCE,
/** ( */
PM_TOKEN_PARENTHESIS_LEFT,
/** ( for a parentheses node */
PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES,
/** % */
PM_TOKEN_PERCENT,
/** %= */
PM_TOKEN_PERCENT_EQUAL,
/** %i */
PM_TOKEN_PERCENT_LOWER_I,
/** %w */
PM_TOKEN_PERCENT_LOWER_W,
/** %x */
PM_TOKEN_PERCENT_LOWER_X,
/** %I */
PM_TOKEN_PERCENT_UPPER_I,
/** %W */
PM_TOKEN_PERCENT_UPPER_W,
/** |= */
PM_TOKEN_PIPE_EQUAL,
/** || */
PM_TOKEN_PIPE_PIPE,
/** ||= */
PM_TOKEN_PIPE_PIPE_EQUAL,
/** + */
PM_TOKEN_PLUS,
/** += */
PM_TOKEN_PLUS_EQUAL,
/** ? */
PM_TOKEN_QUESTION_MARK,
/** the beginning of a regular expression */
PM_TOKEN_REGEXP_BEGIN,
/** the end of a regular expression */
PM_TOKEN_REGEXP_END,
/** / */
PM_TOKEN_SLASH,
/** /= */
PM_TOKEN_SLASH_EQUAL,
/** * */
PM_TOKEN_STAR,
/** *= */
PM_TOKEN_STAR_EQUAL,
/** ** */
PM_TOKEN_STAR_STAR,
/** **= */
PM_TOKEN_STAR_STAR_EQUAL,
/** the beginning of a string */
PM_TOKEN_STRING_BEGIN,
/** the contents of a string */
PM_TOKEN_STRING_CONTENT,
/** the end of a string */
PM_TOKEN_STRING_END,
/** the beginning of a symbol */
PM_TOKEN_SYMBOL_BEGIN,
/** ~ or ~@ */
PM_TOKEN_TILDE,
/** unary & */
PM_TOKEN_UAMPERSAND,
/** unary :: */
PM_TOKEN_UCOLON_COLON,
/** unary .. operator */
PM_TOKEN_UDOT_DOT,
/** unary ... operator */
PM_TOKEN_UDOT_DOT_DOT,
/** -@ */
PM_TOKEN_UMINUS,
/** -@ for a number */
PM_TOKEN_UMINUS_NUM,
/** +@ */
PM_TOKEN_UPLUS,
/** unary * */
PM_TOKEN_USTAR,
/** unary ** */
PM_TOKEN_USTAR_STAR,
/** a separator between words in a list */
PM_TOKEN_WORDS_SEP,
/** marker for the point in the file at which the parser should stop */
PM_TOKEN___END__,
/** a token that was expected but not found */
PM_TOKEN_MISSING,
/** a token that was not present but it is okay */
PM_TOKEN_NOT_PROVIDED,
/** The maximum token value. */
PM_TOKEN_MAXIMUM,
} pm_token_type_t;
/**
* This struct represents a token in the Ruby source. We use it to track both
* type and location information.
*/
typedef struct {
/** The type of the token. */
pm_token_type_t type;
/** A pointer to the start location of the token in the source. */
const uint8_t *start;
/** A pointer to the end location of the token in the source. */
const uint8_t *end;
} pm_token_t;
/**
* This represents a range of bytes in the source string to which a node or
* token corresponds.
*/
typedef struct {
/** A pointer to the start location of the range in the source. */
const uint8_t *start;
/** A pointer to the end location of the range in the source. */
const uint8_t *end;
} pm_location_t;
struct pm_node;
/**
* A list of nodes in the source, most often used for lists of children.
*/
typedef struct pm_node_list {
/** The number of nodes in the list. */
size_t size;
/** The capacity of the list that has been allocated. */
size_t capacity;
/** The nodes in the list. */
struct pm_node **nodes;
} pm_node_list_t;
/**
* This enum represents every type of node in the Ruby syntax tree.
*/
enum pm_node_type {
/** AliasGlobalVariableNode */
PM_ALIAS_GLOBAL_VARIABLE_NODE = 1,
/** AliasMethodNode */
PM_ALIAS_METHOD_NODE = 2,
/** AlternationPatternNode */
PM_ALTERNATION_PATTERN_NODE = 3,
/** AndNode */
PM_AND_NODE = 4,
/** ArgumentsNode */
PM_ARGUMENTS_NODE = 5,
/** ArrayNode */
PM_ARRAY_NODE = 6,
/** ArrayPatternNode */
PM_ARRAY_PATTERN_NODE = 7,
/** AssocNode */
PM_ASSOC_NODE = 8,
/** AssocSplatNode */
PM_ASSOC_SPLAT_NODE = 9,
/** BackReferenceReadNode */
PM_BACK_REFERENCE_READ_NODE = 10,
/** BeginNode */
PM_BEGIN_NODE = 11,
/** BlockArgumentNode */
PM_BLOCK_ARGUMENT_NODE = 12,
/** BlockLocalVariableNode */
PM_BLOCK_LOCAL_VARIABLE_NODE = 13,
/** BlockNode */
PM_BLOCK_NODE = 14,
/** BlockParameterNode */
PM_BLOCK_PARAMETER_NODE = 15,
/** BlockParametersNode */
PM_BLOCK_PARAMETERS_NODE = 16,
/** BreakNode */
PM_BREAK_NODE = 17,
/** CallAndWriteNode */
PM_CALL_AND_WRITE_NODE = 18,
/** CallNode */
PM_CALL_NODE = 19,
/** CallOperatorWriteNode */
PM_CALL_OPERATOR_WRITE_NODE = 20,
/** CallOrWriteNode */
PM_CALL_OR_WRITE_NODE = 21,
/** CallTargetNode */
PM_CALL_TARGET_NODE = 22,
/** CapturePatternNode */
PM_CAPTURE_PATTERN_NODE = 23,
/** CaseMatchNode */
PM_CASE_MATCH_NODE = 24,
/** CaseNode */
PM_CASE_NODE = 25,
/** ClassNode */
PM_CLASS_NODE = 26,
/** ClassVariableAndWriteNode */
PM_CLASS_VARIABLE_AND_WRITE_NODE = 27,
/** ClassVariableOperatorWriteNode */
PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE = 28,
/** ClassVariableOrWriteNode */
PM_CLASS_VARIABLE_OR_WRITE_NODE = 29,
/** ClassVariableReadNode */
PM_CLASS_VARIABLE_READ_NODE = 30,
/** ClassVariableTargetNode */
PM_CLASS_VARIABLE_TARGET_NODE = 31,
/** ClassVariableWriteNode */
PM_CLASS_VARIABLE_WRITE_NODE = 32,
/** ConstantAndWriteNode */
PM_CONSTANT_AND_WRITE_NODE = 33,
/** ConstantOperatorWriteNode */
PM_CONSTANT_OPERATOR_WRITE_NODE = 34,
/** ConstantOrWriteNode */
PM_CONSTANT_OR_WRITE_NODE = 35,
/** ConstantPathAndWriteNode */
PM_CONSTANT_PATH_AND_WRITE_NODE = 36,
/** ConstantPathNode */
PM_CONSTANT_PATH_NODE = 37,
/** ConstantPathOperatorWriteNode */
PM_CONSTANT_PATH_OPERATOR_WRITE_NODE = 38,
/** ConstantPathOrWriteNode */
PM_CONSTANT_PATH_OR_WRITE_NODE = 39,
/** ConstantPathTargetNode */
PM_CONSTANT_PATH_TARGET_NODE = 40,
/** ConstantPathWriteNode */
PM_CONSTANT_PATH_WRITE_NODE = 41,
/** ConstantReadNode */
PM_CONSTANT_READ_NODE = 42,
/** ConstantTargetNode */
PM_CONSTANT_TARGET_NODE = 43,
/** ConstantWriteNode */
PM_CONSTANT_WRITE_NODE = 44,
/** DefNode */
PM_DEF_NODE = 45,
/** DefinedNode */
PM_DEFINED_NODE = 46,
/** ElseNode */
PM_ELSE_NODE = 47,
/** EmbeddedStatementsNode */
PM_EMBEDDED_STATEMENTS_NODE = 48,
/** EmbeddedVariableNode */
PM_EMBEDDED_VARIABLE_NODE = 49,
/** EnsureNode */
PM_ENSURE_NODE = 50,
/** FalseNode */
PM_FALSE_NODE = 51,
/** FindPatternNode */
PM_FIND_PATTERN_NODE = 52,
/** FlipFlopNode */
PM_FLIP_FLOP_NODE = 53,
/** FloatNode */
PM_FLOAT_NODE = 54,
/** ForNode */
PM_FOR_NODE = 55,
/** ForwardingArgumentsNode */
PM_FORWARDING_ARGUMENTS_NODE = 56,
/** ForwardingParameterNode */
PM_FORWARDING_PARAMETER_NODE = 57,
/** ForwardingSuperNode */
PM_FORWARDING_SUPER_NODE = 58,
/** GlobalVariableAndWriteNode */
PM_GLOBAL_VARIABLE_AND_WRITE_NODE = 59,
/** GlobalVariableOperatorWriteNode */
PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE = 60,
/** GlobalVariableOrWriteNode */
PM_GLOBAL_VARIABLE_OR_WRITE_NODE = 61,
/** GlobalVariableReadNode */
PM_GLOBAL_VARIABLE_READ_NODE = 62,
/** GlobalVariableTargetNode */
PM_GLOBAL_VARIABLE_TARGET_NODE = 63,
/** GlobalVariableWriteNode */
PM_GLOBAL_VARIABLE_WRITE_NODE = 64,
/** HashNode */
PM_HASH_NODE = 65,
/** HashPatternNode */
PM_HASH_PATTERN_NODE = 66,
/** IfNode */
PM_IF_NODE = 67,
/** ImaginaryNode */
PM_IMAGINARY_NODE = 68,
/** ImplicitNode */
PM_IMPLICIT_NODE = 69,
/** ImplicitRestNode */
PM_IMPLICIT_REST_NODE = 70,
/** InNode */
PM_IN_NODE = 71,
/** IndexAndWriteNode */
PM_INDEX_AND_WRITE_NODE = 72,
/** IndexOperatorWriteNode */
PM_INDEX_OPERATOR_WRITE_NODE = 73,
/** IndexOrWriteNode */
PM_INDEX_OR_WRITE_NODE = 74,
/** IndexTargetNode */
PM_INDEX_TARGET_NODE = 75,
/** InstanceVariableAndWriteNode */
PM_INSTANCE_VARIABLE_AND_WRITE_NODE = 76,
/** InstanceVariableOperatorWriteNode */
PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE = 77,
/** InstanceVariableOrWriteNode */
PM_INSTANCE_VARIABLE_OR_WRITE_NODE = 78,
/** InstanceVariableReadNode */
PM_INSTANCE_VARIABLE_READ_NODE = 79,
/** InstanceVariableTargetNode */
PM_INSTANCE_VARIABLE_TARGET_NODE = 80,
/** InstanceVariableWriteNode */
PM_INSTANCE_VARIABLE_WRITE_NODE = 81,
/** IntegerNode */
PM_INTEGER_NODE = 82,
/** InterpolatedMatchLastLineNode */
PM_INTERPOLATED_MATCH_LAST_LINE_NODE = 83,
/** InterpolatedRegularExpressionNode */
PM_INTERPOLATED_REGULAR_EXPRESSION_NODE = 84,
/** InterpolatedStringNode */
PM_INTERPOLATED_STRING_NODE = 85,
/** InterpolatedSymbolNode */
PM_INTERPOLATED_SYMBOL_NODE = 86,
/** InterpolatedXStringNode */
PM_INTERPOLATED_X_STRING_NODE = 87,
/** ItLocalVariableReadNode */
PM_IT_LOCAL_VARIABLE_READ_NODE = 88,
/** ItParametersNode */
PM_IT_PARAMETERS_NODE = 89,
/** KeywordHashNode */
PM_KEYWORD_HASH_NODE = 90,
/** KeywordRestParameterNode */
PM_KEYWORD_REST_PARAMETER_NODE = 91,
/** LambdaNode */
PM_LAMBDA_NODE = 92,
/** LocalVariableAndWriteNode */
PM_LOCAL_VARIABLE_AND_WRITE_NODE = 93,
/** LocalVariableOperatorWriteNode */
PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE = 94,
/** LocalVariableOrWriteNode */
PM_LOCAL_VARIABLE_OR_WRITE_NODE = 95,
/** LocalVariableReadNode */
PM_LOCAL_VARIABLE_READ_NODE = 96,
/** LocalVariableTargetNode */
PM_LOCAL_VARIABLE_TARGET_NODE = 97,
/** LocalVariableWriteNode */
PM_LOCAL_VARIABLE_WRITE_NODE = 98,
/** MatchLastLineNode */
PM_MATCH_LAST_LINE_NODE = 99,
/** MatchPredicateNode */
PM_MATCH_PREDICATE_NODE = 100,
/** MatchRequiredNode */
PM_MATCH_REQUIRED_NODE = 101,
/** MatchWriteNode */
PM_MATCH_WRITE_NODE = 102,
/** MissingNode */
PM_MISSING_NODE = 103,
/** ModuleNode */
PM_MODULE_NODE = 104,
/** MultiTargetNode */
PM_MULTI_TARGET_NODE = 105,
/** MultiWriteNode */
PM_MULTI_WRITE_NODE = 106,
/** NextNode */
PM_NEXT_NODE = 107,
/** NilNode */
PM_NIL_NODE = 108,
/** NoKeywordsParameterNode */
PM_NO_KEYWORDS_PARAMETER_NODE = 109,
/** NumberedParametersNode */
PM_NUMBERED_PARAMETERS_NODE = 110,
/** NumberedReferenceReadNode */
PM_NUMBERED_REFERENCE_READ_NODE = 111,
/** OptionalKeywordParameterNode */
PM_OPTIONAL_KEYWORD_PARAMETER_NODE = 112,
/** OptionalParameterNode */
PM_OPTIONAL_PARAMETER_NODE = 113,
/** OrNode */
PM_OR_NODE = 114,
/** ParametersNode */
PM_PARAMETERS_NODE = 115,
/** ParenthesesNode */
PM_PARENTHESES_NODE = 116,
/** PinnedExpressionNode */
PM_PINNED_EXPRESSION_NODE = 117,
/** PinnedVariableNode */
PM_PINNED_VARIABLE_NODE = 118,
/** PostExecutionNode */
PM_POST_EXECUTION_NODE = 119,
/** PreExecutionNode */
PM_PRE_EXECUTION_NODE = 120,
/** ProgramNode */
PM_PROGRAM_NODE = 121,
/** RangeNode */
PM_RANGE_NODE = 122,
/** RationalNode */
PM_RATIONAL_NODE = 123,
/** RedoNode */
PM_REDO_NODE = 124,
/** RegularExpressionNode */
PM_REGULAR_EXPRESSION_NODE = 125,
/** RequiredKeywordParameterNode */
PM_REQUIRED_KEYWORD_PARAMETER_NODE = 126,
/** RequiredParameterNode */
PM_REQUIRED_PARAMETER_NODE = 127,
/** RescueModifierNode */
PM_RESCUE_MODIFIER_NODE = 128,
/** RescueNode */
PM_RESCUE_NODE = 129,
/** RestParameterNode */
PM_REST_PARAMETER_NODE = 130,
/** RetryNode */
PM_RETRY_NODE = 131,
/** ReturnNode */
PM_RETURN_NODE = 132,
/** SelfNode */
PM_SELF_NODE = 133,
/** ShareableConstantNode */
PM_SHAREABLE_CONSTANT_NODE = 134,
/** SingletonClassNode */
PM_SINGLETON_CLASS_NODE = 135,
/** SourceEncodingNode */
PM_SOURCE_ENCODING_NODE = 136,
/** SourceFileNode */
PM_SOURCE_FILE_NODE = 137,
/** SourceLineNode */
PM_SOURCE_LINE_NODE = 138,
/** SplatNode */
PM_SPLAT_NODE = 139,
/** StatementsNode */
PM_STATEMENTS_NODE = 140,
/** StringNode */
PM_STRING_NODE = 141,
/** SuperNode */
PM_SUPER_NODE = 142,
/** SymbolNode */
PM_SYMBOL_NODE = 143,
/** TrueNode */
PM_TRUE_NODE = 144,
/** UndefNode */
PM_UNDEF_NODE = 145,
/** UnlessNode */
PM_UNLESS_NODE = 146,
/** UntilNode */
PM_UNTIL_NODE = 147,
/** WhenNode */
PM_WHEN_NODE = 148,
/** WhileNode */
PM_WHILE_NODE = 149,
/** XStringNode */
PM_X_STRING_NODE = 150,
/** YieldNode */
PM_YIELD_NODE = 151,
/** A special kind of node used for compilation. */
PM_SCOPE_NODE
};
/**
* This is the type of node embedded in the node struct. We explicitly control
* the size of it here to avoid having the variable-width enum.
*/
typedef uint16_t pm_node_type_t;
/**
* These are the flags embedded in the node struct. We explicitly control the
* size of it here to avoid having the variable-width enum.
*/
typedef uint16_t pm_node_flags_t;
/**
* We store the flags enum in every node in the tree. Some flags are common to
* all nodes (the ones listed below). Others are specific to certain node types.
*/
static const pm_node_flags_t PM_NODE_FLAG_NEWLINE = 0x1;
static const pm_node_flags_t PM_NODE_FLAG_STATIC_LITERAL = 0x2;
/**
* This is the base structure that represents a node in the syntax tree. It is
* embedded into every node type.
*/
typedef struct pm_node {
/**
* This represents the type of the node. It somewhat maps to the nodes that
* existed in the original grammar and ripper, but it's not a 1:1 mapping.
*/
pm_node_type_t type;
/**
* This represents any flags on the node. Some are common to all nodes, and
* some are specific to the type of node.
*/
pm_node_flags_t flags;
/**
* The unique identifier for this node, which is deterministic based on the
* source. It is used to identify unique nodes across parses.
*/
uint32_t node_id;
/**
* This is the location of the node in the source. It's a range of bytes
* containing a start and an end.
*/
pm_location_t location;
} pm_node_t;
/**
* Cast the given node to the base pm_node_t type.
*/
#define PM_NODE_UPCAST(node_) ((pm_node_t *) (node_))
/**
* Cast the type to an enum to allow the compiler to provide exhaustiveness
* checking.
*/
#define PM_NODE_TYPE(node_) ((enum pm_node_type) (node_)->type)
/**
* Return true if the type of the given node matches the given type.
*/
#define PM_NODE_TYPE_P(node_, type_) (PM_NODE_TYPE(node_) == (type_))
/**
* Return the flags associated with the given node.
*/
#define PM_NODE_FLAGS(node_) (PM_NODE_UPCAST(node_)->flags)
/**
* Return true if the given flag is set on the given node.
*/
#define PM_NODE_FLAG_P(node_, flag_) ((PM_NODE_FLAGS(node_) & (flag_)) != 0)
/**
* AliasGlobalVariableNode
*
* Represents the use of the `alias` keyword to alias a global variable.
*
* alias $foo $bar
* ^^^^^^^^^^^^^^^
*
* Type: ::PM_ALIAS_GLOBAL_VARIABLE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_alias_global_variable_node {
/** The embedded base node. */
pm_node_t base;
/**
* AliasGlobalVariableNode#new_name
*
* Represents the new name of the global variable that can be used after aliasing.
*
* alias $foo $bar
* ^^^^
*/
struct pm_node *new_name;
/**
* AliasGlobalVariableNode#old_name
*
* Represents the old name of the global variable that can be used before aliasing.
*
* alias $foo $bar
* ^^^^
*/
struct pm_node *old_name;
/**
* AliasGlobalVariableNode#keyword_loc
*
* The location of the `alias` keyword.
*
* alias $foo $bar
* ^^^^^
*/
pm_location_t keyword_loc;
} pm_alias_global_variable_node_t;
/**
* AliasMethodNode
*
* Represents the use of the `alias` keyword to alias a method.
*
* alias foo bar
* ^^^^^^^^^^^^^
*
* Type: ::PM_ALIAS_METHOD_NODE
*
* @extends pm_node_t
*/
typedef struct pm_alias_method_node {
/** The embedded base node. */
pm_node_t base;
/**
* AliasMethodNode#new_name
*
* Represents the new name of the method that will be aliased.
*
* alias foo bar
* ^^^
*
* alias :foo :bar
* ^^^^
*
* alias :"#{foo}" :"#{bar}"
* ^^^^^^^^^
*/
struct pm_node *new_name;
/**
* AliasMethodNode#old_name
*
* Represents the old name of the method that will be aliased.
*
* alias foo bar
* ^^^
*
* alias :foo :bar
* ^^^^
*
* alias :"#{foo}" :"#{bar}"
* ^^^^^^^^^
*/
struct pm_node *old_name;
/**
* AliasMethodNode#keyword_loc
*
* Represents the location of the `alias` keyword.
*
* alias foo bar
* ^^^^^
*/
pm_location_t keyword_loc;
} pm_alias_method_node_t;
/**
* AlternationPatternNode
*
* Represents an alternation pattern in pattern matching.
*
* foo => bar | baz
* ^^^^^^^^^
*
* Type: ::PM_ALTERNATION_PATTERN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_alternation_pattern_node {
/** The embedded base node. */
pm_node_t base;
/**
* AlternationPatternNode#left
*
* Represents the left side of the expression.
*
* foo => bar | baz
* ^^^
*/
struct pm_node *left;
/**
* AlternationPatternNode#right
*
* Represents the right side of the expression.
*
* foo => bar | baz
* ^^^
*/
struct pm_node *right;
/**
* AlternationPatternNode#operator_loc
*
* Represents the alternation operator location.
*
* foo => bar | baz
* ^
*/
pm_location_t operator_loc;
} pm_alternation_pattern_node_t;
/**
* AndNode
*
* Represents the use of the `&&` operator or the `and` keyword.
*
* left and right
* ^^^^^^^^^^^^^^
*
* Type: ::PM_AND_NODE
*
* @extends pm_node_t
*/
typedef struct pm_and_node {
/** The embedded base node. */
pm_node_t base;
/**
* AndNode#left
*
* Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* left and right
* ^^^^
*
* 1 && 2
* ^
*/
struct pm_node *left;
/**
* AndNode#right
*
* Represents the right side of the expression.
*
* left && right
* ^^^^^
*
* 1 and 2
* ^
*/
struct pm_node *right;
/**
* AndNode#operator_loc
*
* The location of the `and` keyword or the `&&` operator.
*
* left and right
* ^^^
*/
pm_location_t operator_loc;
} pm_and_node_t;
/**
* ArgumentsNode
*
* Represents a set of arguments to a method or a keyword.
*
* return foo, bar, baz
* ^^^^^^^^^^^^^
*
* Type: ::PM_ARGUMENTS_NODE
* Flags (#pm_arguments_node_flags):
* * ::PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING
* * ::PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS
* * ::PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT
* * ::PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT
* * ::PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS
*
* @extends pm_node_t
*/
typedef struct pm_arguments_node {
/** The embedded base node. */
pm_node_t base;
/**
* ArgumentsNode#arguments
*
* The list of arguments, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo(bar, baz)
* ^^^^^^^^
*/
struct pm_node_list arguments;
} pm_arguments_node_t;
/**
* ArrayNode
*
* Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
*
* [1, 2, 3]
* ^^^^^^^^^
*
* Type: ::PM_ARRAY_NODE
* Flags (#pm_array_node_flags):
* * ::PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT
*
* @extends pm_node_t
*/
typedef struct pm_array_node {
/** The embedded base node. */
pm_node_t base;
/**
* ArrayNode#elements
*
* Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
*/
struct pm_node_list elements;
/**
* ArrayNode#opening_loc
*
* Represents the optional source location for the opening token.
*
* [1,2,3] # "["
* %w[foo bar baz] # "%w["
* %I(apple orange banana) # "%I("
* foo = 1, 2, 3 # nil
*/
pm_location_t opening_loc;
/**
* ArrayNode#closing_loc
*
* Represents the optional source location for the closing token.
*
* [1,2,3] # "]"
* %w[foo bar baz] # "]"
* %I(apple orange banana) # ")"
* foo = 1, 2, 3 # nil
*/
pm_location_t closing_loc;
} pm_array_node_t;
/**
* ArrayPatternNode
*
* 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]
* ^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_ARRAY_PATTERN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_array_pattern_node {
/** The embedded base node. */
pm_node_t base;
/**
* ArrayPatternNode#constant
*
* Represents the optional constant preceding the Array
*
* foo in Bar[]
* ^^^
*
* foo in Bar[1, 2, 3]
* ^^^
*
* foo in Bar::Baz[1, 2, 3]
* ^^^^^^^^
*/
struct pm_node *constant;
/**
* ArrayPatternNode#requireds
*
* Represents the required elements of the array pattern.
*
* foo in [1, 2]
* ^ ^
*/
struct pm_node_list requireds;
/**
* ArrayPatternNode#rest
*
* Represents the rest element of the array pattern.
*
* foo in *bar
* ^^^^
*/
struct pm_node *rest;
/**
* ArrayPatternNode#posts
*
* Represents the elements after the rest element of the array pattern.
*
* foo in *bar, baz
* ^^^
*/
struct pm_node_list posts;
/**
* ArrayPatternNode#opening_loc
*
* Represents the opening location of the array pattern.
*
* foo in [1, 2]
* ^
*/
pm_location_t opening_loc;
/**
* ArrayPatternNode#closing_loc
*
* Represents the closing location of the array pattern.
*
* foo in [1, 2]
* ^
*/
pm_location_t closing_loc;
} pm_array_pattern_node_t;
/**
* AssocNode
*
* Represents a hash key/value pair.
*
* { a => b }
* ^^^^^^
*
* Type: ::PM_ASSOC_NODE
*
* @extends pm_node_t
*/
typedef struct pm_assoc_node {
/** The embedded base node. */
pm_node_t base;
/**
* AssocNode#key
*
* The key of the association. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* { a: b }
* ^
*
* { foo => bar }
* ^^^
*
* { def a; end => 1 }
* ^^^^^^^^^^
*/
struct pm_node *key;
/**
* AssocNode#value
*
* The value of the association, if present. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* { foo => bar }
* ^^^
*
* { x: 1 }
* ^
*/
struct pm_node *value;
/**
* AssocNode#operator_loc
*
* The location of the `=>` operator, if present.
*
* { foo => bar }
* ^^
*/
pm_location_t operator_loc;
} pm_assoc_node_t;
/**
* AssocSplatNode
*
* Represents a splat in a hash literal.
*
* { **foo }
* ^^^^^
*
* Type: ::PM_ASSOC_SPLAT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_assoc_splat_node {
/** The embedded base node. */
pm_node_t base;
/**
* AssocSplatNode#value
*
* The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.
*
* { **foo }
* ^^^
*/
struct pm_node *value;
/**
* AssocSplatNode#operator_loc
*
* The location of the `**` operator.
*
* { **x }
* ^^
*/
pm_location_t operator_loc;
} pm_assoc_splat_node_t;
/**
* BackReferenceReadNode
*
* Represents reading a reference to a field in the previous match.
*
* $'
* ^^
*
* Type: ::PM_BACK_REFERENCE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_back_reference_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* BackReferenceReadNode#name
*
* The name of the back-reference variable, including the leading `$`.
*
* $& # name `:$&`
*
* $+ # name `:$+`
*/
pm_constant_id_t name;
} pm_back_reference_read_node_t;
/**
* BeginNode
*
* Represents a begin statement.
*
* begin
* foo
* end
* ^^^^^
*
* Type: ::PM_BEGIN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_begin_node {
/** The embedded base node. */
pm_node_t base;
/**
* BeginNode#begin_keyword_loc
*
* Represents the location of the `begin` keyword.
*
* begin x end
* ^^^^^
*/
pm_location_t begin_keyword_loc;
/**
* BeginNode#statements
*
* Represents the statements within the begin block.
*
* begin x end
* ^
*/
struct pm_statements_node *statements;
/**
* BeginNode#rescue_clause
*
* Represents the rescue clause within the begin block.
*
* begin x; rescue y; end
* ^^^^^^^^
*/
struct pm_rescue_node *rescue_clause;
/**
* BeginNode#else_clause
*
* Represents the else clause within the begin block.
*
* begin x; rescue y; else z; end
* ^^^^^^
*/
struct pm_else_node *else_clause;
/**
* BeginNode#ensure_clause
*
* Represents the ensure clause within the begin block.
*
* begin x; ensure y; end
* ^^^^^^^^
*/
struct pm_ensure_node *ensure_clause;
/**
* BeginNode#end_keyword_loc
*
* Represents the location of the `end` keyword.
*
* begin x end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_begin_node_t;
/**
* BlockArgumentNode
*
* Represents a block argument using `&`.
*
* bar(&args)
* ^^^^^^^^^^
*
* Type: ::PM_BLOCK_ARGUMENT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_block_argument_node {
/** The embedded base node. */
pm_node_t base;
/**
* BlockArgumentNode#expression
*
* The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo(&args)
* ^^^^^
*/
struct pm_node *expression;
/**
* BlockArgumentNode#operator_loc
*
* Represents the location of the `&` operator.
*
* foo(&args)
* ^
*/
pm_location_t operator_loc;
} pm_block_argument_node_t;
/**
* BlockLocalVariableNode
*
* Represents a block local variable.
*
* a { |; b| }
* ^
*
* Type: ::PM_BLOCK_LOCAL_VARIABLE_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_block_local_variable_node {
/** The embedded base node. */
pm_node_t base;
/**
* BlockLocalVariableNode#name
*
* The name of the block local variable.
*
* a { |; b| } # name `:b`
* ^
*/
pm_constant_id_t name;
} pm_block_local_variable_node_t;
/**
* BlockNode
*
* Represents a block of ruby code.
*
* [1, 2, 3].each { |i| puts x }
* ^^^^^^^^^^^^^^
*
* Type: ::PM_BLOCK_NODE
*
* @extends pm_node_t
*/
typedef struct pm_block_node {
/** The embedded base node. */
pm_node_t base;
/**
* BlockNode#locals
*
* The local variables declared in the block.
*
* [1, 2, 3].each { |i| puts x } # locals: [:i]
* ^
*/
pm_constant_id_list_t locals;
/**
* BlockNode#parameters
*
* The parameters of the block.
*
* [1, 2, 3].each { |i| puts x }
* ^^^
* [1, 2, 3].each { puts _1 }
* ^^^^^^^^^^^
* [1, 2, 3].each { puts it }
* ^^^^^^^^^^^
*/
struct pm_node *parameters;
/**
* BlockNode#body
*
* The body of the block.
*
* [1, 2, 3].each { |i| puts x }
* ^^^^^^
*/
struct pm_node *body;
/**
* BlockNode#opening_loc
*
* Represents the location of the opening `{` or `do`.
*
* [1, 2, 3].each { |i| puts x }
* ^
*/
pm_location_t opening_loc;
/**
* BlockNode#closing_loc
*
* Represents the location of the closing `}` or `end`.
*
* [1, 2, 3].each { |i| puts x }
* ^
*/
pm_location_t closing_loc;
} pm_block_node_t;
/**
* BlockParameterNode
*
* Represents a block parameter of a method, block, or lambda definition.
*
* def a(&b)
* ^^
* end
*
* Type: ::PM_BLOCK_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_block_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* BlockParameterNode#name
*
* The name of the block parameter.
*
* def a(&b) # name `:b`
* ^
* end
*/
pm_constant_id_t name;
/**
* BlockParameterNode#name_loc
*
* Represents the location of the block parameter name.
*
* def a(&b)
* ^
*/
pm_location_t name_loc;
/**
* BlockParameterNode#operator_loc
*
* Represents the location of the `&` operator.
*
* def a(&b)
* ^
* end
*/
pm_location_t operator_loc;
} pm_block_parameter_node_t;
/**
* BlockParametersNode
*
* Represents a block's parameters declaration.
*
* -> (a, b = 1; local) { }
* ^^^^^^^^^^^^^^^^^
*
* foo do |a, b = 1; local|
* ^^^^^^^^^^^^^^^^^
* end
*
* Type: ::PM_BLOCK_PARAMETERS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_block_parameters_node {
/** The embedded base node. */
pm_node_t base;
/**
* BlockParametersNode#parameters
*
* Represents the parameters of the block.
*
* -> (a, b = 1; local) { }
* ^^^^^^^^
*
* foo do |a, b = 1; local|
* ^^^^^^^^
* end
*/
struct pm_parameters_node *parameters;
/**
* BlockParametersNode#locals
*
* Represents the local variables of the block.
*
* -> (a, b = 1; local) { }
* ^^^^^
*
* foo do |a, b = 1; local|
* ^^^^^
* end
*/
struct pm_node_list locals;
/**
* BlockParametersNode#opening_loc
*
* Represents the opening location of the block parameters.
*
* -> (a, b = 1; local) { }
* ^
*
* foo do |a, b = 1; local|
* ^
* end
*/
pm_location_t opening_loc;
/**
* BlockParametersNode#closing_loc
*
* Represents the closing location of the block parameters.
*
* -> (a, b = 1; local) { }
* ^
*
* foo do |a, b = 1; local|
* ^
* end
*/
pm_location_t closing_loc;
} pm_block_parameters_node_t;
/**
* BreakNode
*
* Represents the use of the `break` keyword.
*
* break foo
* ^^^^^^^^^
*
* Type: ::PM_BREAK_NODE
*
* @extends pm_node_t
*/
typedef struct pm_break_node {
/** The embedded base node. */
pm_node_t base;
/**
* BreakNode#arguments
*
* The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* break foo
* ^^^
*/
struct pm_arguments_node *arguments;
/**
* BreakNode#keyword_loc
*
* The location of the `break` keyword.
*
* break foo
* ^^^^^
*/
pm_location_t keyword_loc;
} pm_break_node_t;
/**
* CallAndWriteNode
*
* Represents the use of the `&&=` operator on a call.
*
* foo.bar &&= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CALL_AND_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_call_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* CallAndWriteNode#receiver
*
* The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo.bar &&= value
* ^^^
*/
struct pm_node *receiver;
/**
* CallAndWriteNode#call_operator_loc
*
* Represents the location of the call operator.
*
* foo.bar &&= value
* ^
*/
pm_location_t call_operator_loc;
/**
* CallAndWriteNode#message_loc
*
* Represents the location of the message.
*
* foo.bar &&= value
* ^^^
*/
pm_location_t message_loc;
/**
* CallAndWriteNode#read_name
*
* Represents the name of the method being called.
*
* foo.bar &&= value # read_name `:bar`
* ^^^
*/
pm_constant_id_t read_name;
/**
* CallAndWriteNode#write_name
*
* Represents the name of the method being written to.
*
* foo.bar &&= value # write_name `:bar=`
* ^^^
*/
pm_constant_id_t write_name;
/**
* CallAndWriteNode#operator_loc
*
* Represents the location of the operator.
*
* foo.bar &&= value
* ^^^
*/
pm_location_t operator_loc;
/**
* CallAndWriteNode#value
*
* Represents the value being assigned.
*
* foo.bar &&= value
* ^^^^^
*/
struct pm_node *value;
} pm_call_and_write_node_t;
/**
* CallNode
*
* Represents a method call, in all of the various forms that can take.
*
* foo
* ^^^
*
* foo()
* ^^^^^
*
* +foo
* ^^^^
*
* foo + bar
* ^^^^^^^^^
*
* foo.bar
* ^^^^^^^
*
* foo&.bar
* ^^^^^^^^
*
* Type: ::PM_CALL_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_call_node {
/** The embedded base node. */
pm_node_t base;
/**
* CallNode#receiver
*
* The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo.bar
* ^^^
*
* +foo
* ^^^
*
* foo + bar
* ^^^
*/
struct pm_node *receiver;
/**
* CallNode#call_operator_loc
*
* Represents the location of the call operator.
*
* foo.bar
* ^
*
* foo&.bar
* ^^
*/
pm_location_t call_operator_loc;
/**
* CallNode#name
*
* Represents the name of the method being called.
*
* foo.bar # name `:foo`
* ^^^
*/
pm_constant_id_t name;
/**
* CallNode#message_loc
*
* Represents the location of the message.
*
* foo.bar
* ^^^
*/
pm_location_t message_loc;
/**
* CallNode#opening_loc
*
* Represents the location of the left parenthesis.
* foo(bar)
* ^
*/
pm_location_t opening_loc;
/**
* CallNode#arguments
*
* Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo(bar)
* ^^^
*/
struct pm_arguments_node *arguments;
/**
* CallNode#closing_loc
*
* Represents the location of the right parenthesis.
*
* foo(bar)
* ^
*/
pm_location_t closing_loc;
/**
* CallNode#equal_loc
*
* Represents the location of the equal sign, in the case that this is an attribute write.
*
* foo.bar = value
* ^
*
* foo[bar] = value
* ^
*/
pm_location_t equal_loc;
/**
* CallNode#block
*
* Represents the block that is being passed to the method.
*
* foo { |a| a }
* ^^^^^^^^^
*/
struct pm_node *block;
} pm_call_node_t;
/**
* CallOperatorWriteNode
*
* Represents the use of an assignment operator on a call.
*
* foo.bar += baz
* ^^^^^^^^^^^^^^
*
* Type: ::PM_CALL_OPERATOR_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_call_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* CallOperatorWriteNode#receiver
*
* The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo.bar += value
* ^^^
*/
struct pm_node *receiver;
/**
* CallOperatorWriteNode#call_operator_loc
*
* Represents the location of the call operator.
*
* foo.bar += value
* ^
*/
pm_location_t call_operator_loc;
/**
* CallOperatorWriteNode#message_loc
*
* Represents the location of the message.
*
* foo.bar += value
* ^^^
*/
pm_location_t message_loc;
/**
* CallOperatorWriteNode#read_name
*
* Represents the name of the method being called.
*
* foo.bar += value # read_name `:bar`
* ^^^
*/
pm_constant_id_t read_name;
/**
* CallOperatorWriteNode#write_name
*
* Represents the name of the method being written to.
*
* foo.bar += value # write_name `:bar=`
* ^^^
*/
pm_constant_id_t write_name;
/**
* CallOperatorWriteNode#binary_operator
*
* Represents the binary operator being used.
*
* foo.bar += value # binary_operator `:+`
* ^
*/
pm_constant_id_t binary_operator;
/**
* CallOperatorWriteNode#binary_operator_loc
*
* Represents the location of the binary operator.
*
* foo.bar += value
* ^^
*/
pm_location_t binary_operator_loc;
/**
* CallOperatorWriteNode#value
*
* Represents the value being assigned.
*
* foo.bar += value
* ^^^^^
*/
struct pm_node *value;
} pm_call_operator_write_node_t;
/**
* CallOrWriteNode
*
* Represents the use of the `||=` operator on a call.
*
* foo.bar ||= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CALL_OR_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_call_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* CallOrWriteNode#receiver
*
* The object that the method is being called on. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo.bar ||= value
* ^^^
*/
struct pm_node *receiver;
/**
* CallOrWriteNode#call_operator_loc
*
* Represents the location of the call operator.
*
* foo.bar ||= value
* ^
*/
pm_location_t call_operator_loc;
/**
* CallOrWriteNode#message_loc
*
* Represents the location of the message.
*
* foo.bar ||= value
* ^^^
*/
pm_location_t message_loc;
/**
* CallOrWriteNode#read_name
*
* Represents the name of the method being called.
*
* foo.bar ||= value # read_name `:bar`
* ^^^
*/
pm_constant_id_t read_name;
/**
* CallOrWriteNode#write_name
*
* Represents the name of the method being written to.
*
* foo.bar ||= value # write_name `:bar=`
* ^^^
*/
pm_constant_id_t write_name;
/**
* CallOrWriteNode#operator_loc
*
* Represents the location of the operator.
*
* foo.bar ||= value
* ^^^
*/
pm_location_t operator_loc;
/**
* CallOrWriteNode#value
*
* Represents the value being assigned.
*
* foo.bar ||= value
* ^^^^^
*/
struct pm_node *value;
} pm_call_or_write_node_t;
/**
* CallTargetNode
*
* Represents assigning to a method call.
*
* foo.bar, = 1
* ^^^^^^^
*
* begin
* rescue => foo.bar
* ^^^^^^^
* end
*
* for foo.bar in baz do end
* ^^^^^^^
*
* Type: ::PM_CALL_TARGET_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_call_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* CallTargetNode#receiver
*
* The object that the method is being called on. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo.bar = 1
* ^^^
*/
struct pm_node *receiver;
/**
* CallTargetNode#call_operator_loc
*
* Represents the location of the call operator.
*
* foo.bar = 1
* ^
*/
pm_location_t call_operator_loc;
/**
* CallTargetNode#name
*
* Represents the name of the method being called.
*
* foo.bar = 1 # name `:foo`
* ^^^
*/
pm_constant_id_t name;
/**
* CallTargetNode#message_loc
*
* Represents the location of the message.
*
* foo.bar = 1
* ^^^
*/
pm_location_t message_loc;
} pm_call_target_node_t;
/**
* CapturePatternNode
*
* Represents assigning to a local variable in pattern matching.
*
* foo => [bar => baz]
* ^^^^^^^^^^^^
*
* Type: ::PM_CAPTURE_PATTERN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_capture_pattern_node {
/** The embedded base node. */
pm_node_t base;
/**
* CapturePatternNode#value
*
* Represents the value to capture.
*
* foo => bar
* ^^^
*/
struct pm_node *value;
/**
* CapturePatternNode#target
*
* Represents the target of the capture.
*
* foo => bar
* ^^^
*/
struct pm_local_variable_target_node *target;
/**
* CapturePatternNode#operator_loc
*
* Represents the location of the `=>` operator.
*
* foo => bar
* ^^
*/
pm_location_t operator_loc;
} pm_capture_pattern_node_t;
/**
* CaseMatchNode
*
* Represents the use of a case statement for pattern matching.
*
* case true
* in false
* end
* ^^^^^^^^^
*
* Type: ::PM_CASE_MATCH_NODE
*
* @extends pm_node_t
*/
typedef struct pm_case_match_node {
/** The embedded base node. */
pm_node_t base;
/**
* CaseMatchNode#predicate
*
* Represents the predicate of the case match. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* case true; in false; end
* ^^^^
*/
struct pm_node *predicate;
/**
* CaseMatchNode#conditions
*
* Represents the conditions of the case match.
*
* case true; in false; end
* ^^^^^^^^
*/
struct pm_node_list conditions;
/**
* CaseMatchNode#else_clause
*
* Represents the else clause of the case match.
*
* case true; in false; else; end
* ^^^^
*/
struct pm_else_node *else_clause;
/**
* CaseMatchNode#case_keyword_loc
*
* Represents the location of the `case` keyword.
*
* case true; in false; end
* ^^^^
*/
pm_location_t case_keyword_loc;
/**
* CaseMatchNode#end_keyword_loc
*
* Represents the location of the `end` keyword.
*
* case true; in false; end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_case_match_node_t;
/**
* CaseNode
*
* Represents the use of a case statement.
*
* case true
* when false
* end
* ^^^^^^^^^^
*
* Type: ::PM_CASE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_case_node {
/** The embedded base node. */
pm_node_t base;
/**
* CaseNode#predicate
*
* Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* case true; when false; end
* ^^^^
*/
struct pm_node *predicate;
/**
* CaseNode#conditions
*
* Represents the conditions of the case statement.
*
* case true; when false; end
* ^^^^^^^^^^
*/
struct pm_node_list conditions;
/**
* CaseNode#else_clause
*
* Represents the else clause of the case statement.
*
* case true; when false; else; end
* ^^^^
*/
struct pm_else_node *else_clause;
/**
* CaseNode#case_keyword_loc
*
* Represents the location of the `case` keyword.
*
* case true; when false; end
* ^^^^
*/
pm_location_t case_keyword_loc;
/**
* CaseNode#end_keyword_loc
*
* Represents the location of the `end` keyword.
*
* case true; when false; end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_case_node_t;
/**
* ClassNode
*
* Represents a class declaration involving the `class` keyword.
*
* class Foo end
* ^^^^^^^^^^^^^
*
* Type: ::PM_CLASS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassNode#locals
*/
pm_constant_id_list_t locals;
/**
* ClassNode#class_keyword_loc
*
* Represents the location of the `class` keyword.
*
* class Foo end
* ^^^^^
*/
pm_location_t class_keyword_loc;
/**
* ClassNode#constant_path
*/
struct pm_node *constant_path;
/**
* ClassNode#inheritance_operator_loc
*
* Represents the location of the `<` operator.
*
* class Foo < Bar
* ^
*/
pm_location_t inheritance_operator_loc;
/**
* ClassNode#superclass
*
* Represents the superclass of the class.
*
* class Foo < Bar
* ^^^
*/
struct pm_node *superclass;
/**
* ClassNode#body
*
* Represents the body of the class.
*
* class Foo
* foo
* ^^^
*/
struct pm_node *body;
/**
* ClassNode#end_keyword_loc
*
* Represents the location of the `end` keyword.
*
* class Foo end
* ^^^
*/
pm_location_t end_keyword_loc;
/**
* ClassNode#name
*
* The name of the class.
*
* class Foo end # name `:Foo`
*/
pm_constant_id_t name;
} pm_class_node_t;
/**
* ClassVariableAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to a class variable.
*
* @@target &&= value
* ^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CLASS_VARIABLE_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableAndWriteNode#name
*
* The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* @@target &&= value # name `:@@target`
* ^^^^^^^^
*/
pm_constant_id_t name;
/**
* ClassVariableAndWriteNode#name_loc
*
* Represents the location of the variable name.
*
* @@target &&= value
* ^^^^^^^^
*/
pm_location_t name_loc;
/**
* ClassVariableAndWriteNode#operator_loc
*
* Represents the location of the `&&=` operator.
*
* @@target &&= value
* ^^^
*/
pm_location_t operator_loc;
/**
* ClassVariableAndWriteNode#value
*
* Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* @@target &&= value
* ^^^^^
*/
struct pm_node *value;
} pm_class_variable_and_write_node_t;
/**
* ClassVariableOperatorWriteNode
*
* Represents assigning to a class variable using an operator that isn't `=`.
*
* @@target += value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableOperatorWriteNode#name
*/
pm_constant_id_t name;
/**
* ClassVariableOperatorWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* ClassVariableOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* ClassVariableOperatorWriteNode#value
*/
struct pm_node *value;
/**
* ClassVariableOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
} pm_class_variable_operator_write_node_t;
/**
* ClassVariableOrWriteNode
*
* Represents the use of the `||=` operator for assignment to a class variable.
*
* @@target ||= value
* ^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CLASS_VARIABLE_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableOrWriteNode#name
*/
pm_constant_id_t name;
/**
* ClassVariableOrWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* ClassVariableOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* ClassVariableOrWriteNode#value
*/
struct pm_node *value;
} pm_class_variable_or_write_node_t;
/**
* ClassVariableReadNode
*
* Represents referencing a class variable.
*
* @@foo
* ^^^^^
*
* Type: ::PM_CLASS_VARIABLE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableReadNode#name
*
* The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* @@abc # name `:@@abc`
*
* @@_test # name `:@@_test`
*/
pm_constant_id_t name;
} pm_class_variable_read_node_t;
/**
* ClassVariableTargetNode
*
* Represents writing to a class variable in a context that doesn't have an explicit value.
*
* @@foo, @@bar = baz
* ^^^^^ ^^^^^
*
* Type: ::PM_CLASS_VARIABLE_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableTargetNode#name
*/
pm_constant_id_t name;
} pm_class_variable_target_node_t;
/**
* ClassVariableWriteNode
*
* Represents writing to a class variable.
*
* @@foo = 1
* ^^^^^^^^^
*
* Type: ::PM_CLASS_VARIABLE_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_class_variable_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ClassVariableWriteNode#name
*
* The name of the class variable, which is a `@@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* @@abc = 123 # name `@@abc`
*
* @@_test = :test # name `@@_test`
*/
pm_constant_id_t name;
/**
* ClassVariableWriteNode#name_loc
*
* The location of the variable name.
*
* @@foo = :bar
* ^^^^^
*/
pm_location_t name_loc;
/**
* ClassVariableWriteNode#value
*
* The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* @@foo = :bar
* ^^^^
*
* @@_xyz = 123
* ^^^
*/
struct pm_node *value;
/**
* ClassVariableWriteNode#operator_loc
*
* The location of the `=` operator.
*
* @@foo = :bar
* ^
*/
pm_location_t operator_loc;
} pm_class_variable_write_node_t;
/**
* ConstantAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to a constant.
*
* Target &&= value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantAndWriteNode#name
*/
pm_constant_id_t name;
/**
* ConstantAndWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* ConstantAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* ConstantAndWriteNode#value
*/
struct pm_node *value;
} pm_constant_and_write_node_t;
/**
* ConstantOperatorWriteNode
*
* Represents assigning to a constant using an operator that isn't `=`.
*
* Target += value
* ^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantOperatorWriteNode#name
*/
pm_constant_id_t name;
/**
* ConstantOperatorWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* ConstantOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* ConstantOperatorWriteNode#value
*/
struct pm_node *value;
/**
* ConstantOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
} pm_constant_operator_write_node_t;
/**
* ConstantOrWriteNode
*
* Represents the use of the `||=` operator for assignment to a constant.
*
* Target ||= value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantOrWriteNode#name
*/
pm_constant_id_t name;
/**
* ConstantOrWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* ConstantOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* ConstantOrWriteNode#value
*/
struct pm_node *value;
} pm_constant_or_write_node_t;
/**
* ConstantPathAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to a constant path.
*
* Parent::Child &&= value
* ^^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathAndWriteNode#target
*/
struct pm_constant_path_node *target;
/**
* ConstantPathAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* ConstantPathAndWriteNode#value
*/
struct pm_node *value;
} pm_constant_path_and_write_node_t;
/**
* ConstantPathNode
*
* Represents accessing a constant through a path of `::` operators.
*
* Foo::Bar
* ^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathNode#parent
*
* The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
*
* Foo::Bar
* ^^^
*
* self::Test
* ^^^^
*
* a.b::C
* ^^^
*/
struct pm_node *parent;
/**
* ConstantPathNode#name
*
* The name of the constant being accessed. This could be `nil` in the event of a syntax error.
*/
pm_constant_id_t name;
/**
* ConstantPathNode#delimiter_loc
*
* The location of the `::` delimiter.
*
* ::Foo
* ^^
*
* One::Two
* ^^
*/
pm_location_t delimiter_loc;
/**
* ConstantPathNode#name_loc
*
* The location of the name of the constant.
*
* ::Foo
* ^^^
*
* One::Two
* ^^^
*/
pm_location_t name_loc;
} pm_constant_path_node_t;
/**
* ConstantPathOperatorWriteNode
*
* Represents assigning to a constant path using an operator that isn't `=`.
*
* Parent::Child += value
* ^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathOperatorWriteNode#target
*/
struct pm_constant_path_node *target;
/**
* ConstantPathOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* ConstantPathOperatorWriteNode#value
*/
struct pm_node *value;
/**
* ConstantPathOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
} pm_constant_path_operator_write_node_t;
/**
* ConstantPathOrWriteNode
*
* Represents the use of the `||=` operator for assignment to a constant path.
*
* Parent::Child ||= value
* ^^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathOrWriteNode#target
*/
struct pm_constant_path_node *target;
/**
* ConstantPathOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* ConstantPathOrWriteNode#value
*/
struct pm_node *value;
} pm_constant_path_or_write_node_t;
/**
* ConstantPathTargetNode
*
* Represents writing to a constant path in a context that doesn't have an explicit value.
*
* Foo::Foo, Bar::Bar = baz
* ^^^^^^^^ ^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathTargetNode#parent
*/
struct pm_node *parent;
/**
* ConstantPathTargetNode#name
*/
pm_constant_id_t name;
/**
* ConstantPathTargetNode#delimiter_loc
*/
pm_location_t delimiter_loc;
/**
* ConstantPathTargetNode#name_loc
*/
pm_location_t name_loc;
} pm_constant_path_target_node_t;
/**
* ConstantPathWriteNode
*
* Represents writing to a constant path.
*
* ::Foo = 1
* ^^^^^^^^^
*
* Foo::Bar = 1
* ^^^^^^^^^^^^
*
* ::Foo::Bar = 1
* ^^^^^^^^^^^^^^
*
* Type: ::PM_CONSTANT_PATH_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_path_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantPathWriteNode#target
*
* A node representing the constant path being written to.
*
* Foo::Bar = 1
* ^^^^^^^^
*
* ::Foo = :abc
* ^^^^^
*/
struct pm_constant_path_node *target;
/**
* ConstantPathWriteNode#operator_loc
*
* The location of the `=` operator.
*
* ::ABC = 123
* ^
*/
pm_location_t operator_loc;
/**
* ConstantPathWriteNode#value
*
* The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* FOO::BAR = :abc
* ^^^^
*/
struct pm_node *value;
} pm_constant_path_write_node_t;
/**
* ConstantReadNode
*
* Represents referencing a constant.
*
* Foo
* ^^^
*
* Type: ::PM_CONSTANT_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantReadNode#name
*
* The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
*
* X # name `:X`
*
* SOME_CONSTANT # name `:SOME_CONSTANT`
*/
pm_constant_id_t name;
} pm_constant_read_node_t;
/**
* ConstantTargetNode
*
* Represents writing to a constant in a context that doesn't have an explicit value.
*
* Foo, Bar = baz
* ^^^ ^^^
*
* Type: ::PM_CONSTANT_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantTargetNode#name
*/
pm_constant_id_t name;
} pm_constant_target_node_t;
/**
* ConstantWriteNode
*
* Represents writing to a constant.
*
* Foo = 1
* ^^^^^^^
*
* Type: ::PM_CONSTANT_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_constant_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* ConstantWriteNode#name
*
* The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
*
* Foo = :bar # name `:Foo`
*
* XYZ = 1 # name `:XYZ`
*/
pm_constant_id_t name;
/**
* ConstantWriteNode#name_loc
*
* The location of the constant name.
*
* FOO = 1
* ^^^
*/
pm_location_t name_loc;
/**
* ConstantWriteNode#value
*
* The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* FOO = :bar
* ^^^^
*
* MyClass = Class.new
* ^^^^^^^^^
*/
struct pm_node *value;
/**
* ConstantWriteNode#operator_loc
*
* The location of the `=` operator.
*
* FOO = :bar
* ^
*/
pm_location_t operator_loc;
} pm_constant_write_node_t;
/**
* DefNode
*
* Represents a method definition.
*
* def method
* end
* ^^^^^^^^^^
*
* Type: ::PM_DEF_NODE
*
* @extends pm_node_t
*/
typedef struct pm_def_node {
/** The embedded base node. */
pm_node_t base;
/**
* DefNode#name
*/
pm_constant_id_t name;
/**
* DefNode#name_loc
*/
pm_location_t name_loc;
/**
* DefNode#receiver
*/
struct pm_node *receiver;
/**
* DefNode#parameters
*/
struct pm_parameters_node *parameters;
/**
* DefNode#body
*/
struct pm_node *body;
/**
* DefNode#locals
*/
pm_constant_id_list_t locals;
/**
* DefNode#def_keyword_loc
*/
pm_location_t def_keyword_loc;
/**
* DefNode#operator_loc
*/
pm_location_t operator_loc;
/**
* DefNode#lparen_loc
*/
pm_location_t lparen_loc;
/**
* DefNode#rparen_loc
*/
pm_location_t rparen_loc;
/**
* DefNode#equal_loc
*/
pm_location_t equal_loc;
/**
* DefNode#end_keyword_loc
*/
pm_location_t end_keyword_loc;
} pm_def_node_t;
/**
* DefinedNode
*
* Represents the use of the `defined?` keyword.
*
* defined?(a)
* ^^^^^^^^^^^
*
* Type: ::PM_DEFINED_NODE
*
* @extends pm_node_t
*/
typedef struct pm_defined_node {
/** The embedded base node. */
pm_node_t base;
/**
* DefinedNode#lparen_loc
*/
pm_location_t lparen_loc;
/**
* DefinedNode#value
*/
struct pm_node *value;
/**
* DefinedNode#rparen_loc
*/
pm_location_t rparen_loc;
/**
* DefinedNode#keyword_loc
*/
pm_location_t keyword_loc;
} pm_defined_node_t;
/**
* ElseNode
*
* Represents an `else` clause in a `case`, `if`, or `unless` statement.
*
* if a then b else c end
* ^^^^^^^^^^
*
* Type: ::PM_ELSE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_else_node {
/** The embedded base node. */
pm_node_t base;
/**
* ElseNode#else_keyword_loc
*/
pm_location_t else_keyword_loc;
/**
* ElseNode#statements
*/
struct pm_statements_node *statements;
/**
* ElseNode#end_keyword_loc
*/
pm_location_t end_keyword_loc;
} pm_else_node_t;
/**
* EmbeddedStatementsNode
*
* Represents an interpolated set of statements.
*
* "foo #{bar}"
* ^^^^^^
*
* Type: ::PM_EMBEDDED_STATEMENTS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_embedded_statements_node {
/** The embedded base node. */
pm_node_t base;
/**
* EmbeddedStatementsNode#opening_loc
*/
pm_location_t opening_loc;
/**
* EmbeddedStatementsNode#statements
*/
struct pm_statements_node *statements;
/**
* EmbeddedStatementsNode#closing_loc
*/
pm_location_t closing_loc;
} pm_embedded_statements_node_t;
/**
* EmbeddedVariableNode
*
* Represents an interpolated variable.
*
* "foo #@bar"
* ^^^^^
*
* Type: ::PM_EMBEDDED_VARIABLE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_embedded_variable_node {
/** The embedded base node. */
pm_node_t base;
/**
* EmbeddedVariableNode#operator_loc
*/
pm_location_t operator_loc;
/**
* EmbeddedVariableNode#variable
*/
struct pm_node *variable;
} pm_embedded_variable_node_t;
/**
* EnsureNode
*
* Represents an `ensure` clause in a `begin` statement.
*
* begin
* foo
* ensure
* ^^^^^^
* bar
* end
*
* Type: ::PM_ENSURE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_ensure_node {
/** The embedded base node. */
pm_node_t base;
/**
* EnsureNode#ensure_keyword_loc
*/
pm_location_t ensure_keyword_loc;
/**
* EnsureNode#statements
*/
struct pm_statements_node *statements;
/**
* EnsureNode#end_keyword_loc
*/
pm_location_t end_keyword_loc;
} pm_ensure_node_t;
/**
* FalseNode
*
* Represents the use of the literal `false` keyword.
*
* false
* ^^^^^
*
* Type: ::PM_FALSE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_false_node {
/** The embedded base node. */
pm_node_t base;
} pm_false_node_t;
/**
* FindPatternNode
*
* 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
* ^^^^^^^^^^^^^^^
*
* Type: ::PM_FIND_PATTERN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_find_pattern_node {
/** The embedded base node. */
pm_node_t base;
/**
* FindPatternNode#constant
*
* Represents the optional constant preceding the pattern
*
* foo in Foo(*bar, baz, *qux)
* ^^^
*/
struct pm_node *constant;
/**
* FindPatternNode#left
*
* Represents the first wildcard node in the pattern.
*
* foo in *bar, baz, *qux
* ^^^^
*
* foo in Foo(*bar, baz, *qux)
* ^^^^
*/
struct pm_splat_node *left;
/**
* FindPatternNode#requireds
*
* Represents the nodes in between the wildcards.
*
* foo in *bar, baz, *qux
* ^^^
*
* foo in Foo(*bar, baz, 1, *qux)
* ^^^^^^
*/
struct pm_node_list requireds;
/**
* FindPatternNode#right
*
* Represents the second wildcard node in the pattern.
*
* foo in *bar, baz, *qux
* ^^^^
*
* foo in Foo(*bar, baz, *qux)
* ^^^^
*/
struct pm_node *right;
/**
* FindPatternNode#opening_loc
*
* The location of the opening brace.
*
* foo in [*bar, baz, *qux]
* ^
*
* foo in Foo(*bar, baz, *qux)
* ^
*/
pm_location_t opening_loc;
/**
* FindPatternNode#closing_loc
*
* The location of the closing brace.
*
* foo in [*bar, baz, *qux]
* ^
*
* foo in Foo(*bar, baz, *qux)
* ^
*/
pm_location_t closing_loc;
} pm_find_pattern_node_t;
/**
* FlipFlopNode
*
* Represents the use of the `..` or `...` operators to create flip flops.
*
* baz if foo .. bar
* ^^^^^^^^^^
*
* Type: ::PM_FLIP_FLOP_NODE
* Flags (#pm_range_flags):
* * ::PM_RANGE_FLAGS_EXCLUDE_END
*
* @extends pm_node_t
*/
typedef struct pm_flip_flop_node {
/** The embedded base node. */
pm_node_t base;
/**
* FlipFlopNode#left
*/
struct pm_node *left;
/**
* FlipFlopNode#right
*/
struct pm_node *right;
/**
* FlipFlopNode#operator_loc
*/
pm_location_t operator_loc;
} pm_flip_flop_node_t;
/**
* FloatNode
*
* Represents a floating point number literal.
*
* 1.0
* ^^^
*
* Type: ::PM_FLOAT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_float_node {
/** The embedded base node. */
pm_node_t base;
/**
* FloatNode#value
*
* The value of the floating point number as a Float.
*/
double value;
} pm_float_node_t;
/**
* ForNode
*
* Represents the use of the `for` keyword.
*
* for i in a end
* ^^^^^^^^^^^^^^
*
* Type: ::PM_FOR_NODE
*
* @extends pm_node_t
*/
typedef struct pm_for_node {
/** The embedded base node. */
pm_node_t base;
/**
* ForNode#index
*
* The index expression for `for` loops.
*
* for i in a end
* ^
*/
struct pm_node *index;
/**
* ForNode#collection
*
* The collection to iterate over.
*
* for i in a end
* ^
*/
struct pm_node *collection;
/**
* ForNode#statements
*
* Represents the body of statements to execute for each iteration of the loop.
*
* for i in a
* foo(i)
* ^^^^^^
* end
*/
struct pm_statements_node *statements;
/**
* ForNode#for_keyword_loc
*
* The location of the `for` keyword.
*
* for i in a end
* ^^^
*/
pm_location_t for_keyword_loc;
/**
* ForNode#in_keyword_loc
*
* The location of the `in` keyword.
*
* for i in a end
* ^^
*/
pm_location_t in_keyword_loc;
/**
* ForNode#do_keyword_loc
*
* The location of the `do` keyword, if present.
*
* for i in a do end
* ^^
*/
pm_location_t do_keyword_loc;
/**
* ForNode#end_keyword_loc
*
* The location of the `end` keyword.
*
* for i in a end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_for_node_t;
/**
* ForwardingArgumentsNode
*
* Represents forwarding all arguments to this method to another method.
*
* def foo(...)
* bar(...)
* ^^^
* end
*
* Type: ::PM_FORWARDING_ARGUMENTS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_forwarding_arguments_node {
/** The embedded base node. */
pm_node_t base;
} pm_forwarding_arguments_node_t;
/**
* ForwardingParameterNode
*
* Represents the use of the forwarding parameter in a method, block, or lambda declaration.
*
* def foo(...)
* ^^^
* end
*
* Type: ::PM_FORWARDING_PARAMETER_NODE
*
* @extends pm_node_t
*/
typedef struct pm_forwarding_parameter_node {
/** The embedded base node. */
pm_node_t base;
} pm_forwarding_parameter_node_t;
/**
* ForwardingSuperNode
*
* 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.
*
* Type: ::PM_FORWARDING_SUPER_NODE
*
* @extends pm_node_t
*/
typedef struct pm_forwarding_super_node {
/** The embedded base node. */
pm_node_t base;
/**
* ForwardingSuperNode#block
*
* All other arguments are forwarded as normal, except the original block is replaced with the new block.
*/
struct pm_block_node *block;
} pm_forwarding_super_node_t;
/**
* GlobalVariableAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to a global variable.
*
* $target &&= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableAndWriteNode#name
*/
pm_constant_id_t name;
/**
* GlobalVariableAndWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* GlobalVariableAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* GlobalVariableAndWriteNode#value
*/
struct pm_node *value;
} pm_global_variable_and_write_node_t;
/**
* GlobalVariableOperatorWriteNode
*
* Represents assigning to a global variable using an operator that isn't `=`.
*
* $target += value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableOperatorWriteNode#name
*/
pm_constant_id_t name;
/**
* GlobalVariableOperatorWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* GlobalVariableOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* GlobalVariableOperatorWriteNode#value
*/
struct pm_node *value;
/**
* GlobalVariableOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
} pm_global_variable_operator_write_node_t;
/**
* GlobalVariableOrWriteNode
*
* Represents the use of the `||=` operator for assignment to a global variable.
*
* $target ||= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableOrWriteNode#name
*/
pm_constant_id_t name;
/**
* GlobalVariableOrWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* GlobalVariableOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* GlobalVariableOrWriteNode#value
*/
struct pm_node *value;
} pm_global_variable_or_write_node_t;
/**
* GlobalVariableReadNode
*
* Represents referencing a global variable.
*
* $foo
* ^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableReadNode#name
*
* The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
*
* $foo # name `:$foo`
*
* $_Test # name `:$_Test`
*/
pm_constant_id_t name;
} pm_global_variable_read_node_t;
/**
* GlobalVariableTargetNode
*
* Represents writing to a global variable in a context that doesn't have an explicit value.
*
* $foo, $bar = baz
* ^^^^ ^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableTargetNode#name
*/
pm_constant_id_t name;
} pm_global_variable_target_node_t;
/**
* GlobalVariableWriteNode
*
* Represents writing to a global variable.
*
* $foo = 1
* ^^^^^^^^
*
* Type: ::PM_GLOBAL_VARIABLE_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_global_variable_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* GlobalVariableWriteNode#name
*
* The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
*
* $foo = :bar # name `:$foo`
*
* $_Test = 123 # name `:$_Test`
*/
pm_constant_id_t name;
/**
* GlobalVariableWriteNode#name_loc
*
* The location of the global variable's name.
*
* $foo = :bar
* ^^^^
*/
pm_location_t name_loc;
/**
* GlobalVariableWriteNode#value
*
* The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* $foo = :bar
* ^^^^
*
* $-xyz = 123
* ^^^
*/
struct pm_node *value;
/**
* GlobalVariableWriteNode#operator_loc
*
* The location of the `=` operator.
*
* $foo = :bar
* ^
*/
pm_location_t operator_loc;
} pm_global_variable_write_node_t;
/**
* HashNode
*
* Represents a hash literal.
*
* { a => b }
* ^^^^^^^^^^
*
* Type: ::PM_HASH_NODE
*
* @extends pm_node_t
*/
typedef struct pm_hash_node {
/** The embedded base node. */
pm_node_t base;
/**
* HashNode#opening_loc
*
* The location of the opening brace.
*
* { a => b }
* ^
*/
pm_location_t opening_loc;
/**
* HashNode#elements
*
* The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.
*
* { a: b }
* ^^^^
*
* { **foo }
* ^^^^^
*/
struct pm_node_list elements;
/**
* HashNode#closing_loc
*
* The location of the closing brace.
*
* { a => b }
* ^
*/
pm_location_t closing_loc;
} pm_hash_node_t;
/**
* HashPatternNode
*
* 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 }
* ^^^^^^^^^^^^^^
*
* Type: ::PM_HASH_PATTERN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_hash_pattern_node {
/** The embedded base node. */
pm_node_t base;
/**
* HashPatternNode#constant
*
* Represents the optional constant preceding the Hash.
*
* foo => Bar[a: 1, b: 2]
* ^^^
*
* foo => Bar::Baz[a: 1, b: 2]
* ^^^^^^^^
*/
struct pm_node *constant;
/**
* HashPatternNode#elements
*
* Represents the explicit named hash keys and values.
*
* foo => { a: 1, b:, ** }
* ^^^^^^^^
*/
struct pm_node_list elements;
/**
* HashPatternNode#rest
*
* Represents the rest of the Hash keys and values. This can be named, unnamed, or explicitly forbidden via `**nil`, this last one results in a `NoKeywordsParameterNode`.
*
* foo => { a: 1, b:, **c }
* ^^^
*
* foo => { a: 1, b:, ** }
* ^^
*
* foo => { a: 1, b:, **nil }
* ^^^^^
*/
struct pm_node *rest;
/**
* HashPatternNode#opening_loc
*
* The location of the opening brace.
*
* foo => { a: 1 }
* ^
*
* foo => Bar[a: 1]
* ^
*/
pm_location_t opening_loc;
/**
* HashPatternNode#closing_loc
*
* The location of the closing brace.
*
* foo => { a: 1 }
* ^
*
* foo => Bar[a: 1]
* ^
*/
pm_location_t closing_loc;
} pm_hash_pattern_node_t;
/**
* IfNode
*
* 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
* ^^^^^^^^^^^^^^^
*
* Type: ::PM_IF_NODE
*
* @extends pm_node_t
*/
typedef struct pm_if_node {
/** The embedded base node. */
pm_node_t base;
/**
* IfNode#if_keyword_loc
*
* The location of the `if` keyword if present.
*
* bar if foo
* ^^
*
* The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
*/
pm_location_t if_keyword_loc;
/**
* IfNode#predicate
*
* The node for the condition the `IfNode` is testing.
*
* if foo
* ^^^
* bar
* end
*
* bar if foo
* ^^^
*
* foo ? bar : baz
* ^^^
*/
struct pm_node *predicate;
/**
* IfNode#then_keyword_loc
*
* The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
*
* if foo then bar end
* ^^^^
*
* a ? b : c
* ^
*/
pm_location_t then_keyword_loc;
/**
* IfNode#statements
*
* Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
*
* if foo
* bar
* ^^^
* baz
* ^^^
* end
*/
struct pm_statements_node *statements;
/**
* IfNode#subsequent
*
* Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
*
* if foo
* bar
* elsif baz
* ^^^^^^^^^
* qux
* ^^^
* end
* ^^^
*
* if foo then bar else baz end
* ^^^^^^^^^^^^
*/
struct pm_node *subsequent;
/**
* IfNode#end_keyword_loc
*
* The location of the `end` keyword if present, `nil` otherwise.
*
* if foo
* bar
* end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_if_node_t;
/**
* ImaginaryNode
*
* Represents an imaginary number literal.
*
* 1.0i
* ^^^^
*
* Type: ::PM_IMAGINARY_NODE
*
* @extends pm_node_t
*/
typedef struct pm_imaginary_node {
/** The embedded base node. */
pm_node_t base;
/**
* ImaginaryNode#numeric
*/
struct pm_node *numeric;
} pm_imaginary_node_t;
/**
* ImplicitNode
*
* 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: }
* ^^^^
*
* Type: ::PM_IMPLICIT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_implicit_node {
/** The embedded base node. */
pm_node_t base;
/**
* ImplicitNode#value
*/
struct pm_node *value;
} pm_implicit_node_t;
/**
* ImplicitRestNode
*
* Represents using a trailing comma to indicate an implicit rest parameter.
*
* foo { |bar,| }
* ^
*
* foo in [bar,]
* ^
*
* for foo, in bar do end
* ^
*
* foo, = bar
* ^
*
* Type: ::PM_IMPLICIT_REST_NODE
*
* @extends pm_node_t
*/
typedef struct pm_implicit_rest_node {
/** The embedded base node. */
pm_node_t base;
} pm_implicit_rest_node_t;
/**
* InNode
*
* Represents the use of the `in` keyword in a case statement.
*
* case a; in b then c end
* ^^^^^^^^^^^
*
* Type: ::PM_IN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_in_node {
/** The embedded base node. */
pm_node_t base;
/**
* InNode#pattern
*/
struct pm_node *pattern;
/**
* InNode#statements
*/
struct pm_statements_node *statements;
/**
* InNode#in_loc
*/
pm_location_t in_loc;
/**
* InNode#then_loc
*/
pm_location_t then_loc;
} pm_in_node_t;
/**
* IndexAndWriteNode
*
* Represents the use of the `&&=` operator on a call to the `[]` method.
*
* foo.bar[baz] &&= value
* ^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INDEX_AND_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_index_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* IndexAndWriteNode#receiver
*/
struct pm_node *receiver;
/**
* IndexAndWriteNode#call_operator_loc
*/
pm_location_t call_operator_loc;
/**
* IndexAndWriteNode#opening_loc
*/
pm_location_t opening_loc;
/**
* IndexAndWriteNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* IndexAndWriteNode#closing_loc
*/
pm_location_t closing_loc;
/**
* IndexAndWriteNode#block
*/
struct pm_block_argument_node *block;
/**
* IndexAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* IndexAndWriteNode#value
*/
struct pm_node *value;
} pm_index_and_write_node_t;
/**
* IndexOperatorWriteNode
*
* Represents the use of an assignment operator on a call to `[]`.
*
* foo.bar[baz] += value
* ^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INDEX_OPERATOR_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_index_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* IndexOperatorWriteNode#receiver
*/
struct pm_node *receiver;
/**
* IndexOperatorWriteNode#call_operator_loc
*/
pm_location_t call_operator_loc;
/**
* IndexOperatorWriteNode#opening_loc
*/
pm_location_t opening_loc;
/**
* IndexOperatorWriteNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* IndexOperatorWriteNode#closing_loc
*/
pm_location_t closing_loc;
/**
* IndexOperatorWriteNode#block
*/
struct pm_block_argument_node *block;
/**
* IndexOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
/**
* IndexOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* IndexOperatorWriteNode#value
*/
struct pm_node *value;
} pm_index_operator_write_node_t;
/**
* IndexOrWriteNode
*
* Represents the use of the `||=` operator on a call to `[]`.
*
* foo.bar[baz] ||= value
* ^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INDEX_OR_WRITE_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_index_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* IndexOrWriteNode#receiver
*/
struct pm_node *receiver;
/**
* IndexOrWriteNode#call_operator_loc
*/
pm_location_t call_operator_loc;
/**
* IndexOrWriteNode#opening_loc
*/
pm_location_t opening_loc;
/**
* IndexOrWriteNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* IndexOrWriteNode#closing_loc
*/
pm_location_t closing_loc;
/**
* IndexOrWriteNode#block
*/
struct pm_block_argument_node *block;
/**
* IndexOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* IndexOrWriteNode#value
*/
struct pm_node *value;
} pm_index_or_write_node_t;
/**
* IndexTargetNode
*
* Represents assigning to an index.
*
* foo[bar], = 1
* ^^^^^^^^
*
* begin
* rescue => foo[bar]
* ^^^^^^^^
* end
*
* for foo[bar] in baz do end
* ^^^^^^^^
*
* Type: ::PM_INDEX_TARGET_NODE
* Flags (#pm_call_node_flags):
* * ::PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
* * ::PM_CALL_NODE_FLAGS_VARIABLE_CALL
* * ::PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
* * ::PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
*
* @extends pm_node_t
*/
typedef struct pm_index_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* IndexTargetNode#receiver
*/
struct pm_node *receiver;
/**
* IndexTargetNode#opening_loc
*/
pm_location_t opening_loc;
/**
* IndexTargetNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* IndexTargetNode#closing_loc
*/
pm_location_t closing_loc;
/**
* IndexTargetNode#block
*/
struct pm_block_argument_node *block;
} pm_index_target_node_t;
/**
* InstanceVariableAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to an instance variable.
*
* @target &&= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableAndWriteNode#name
*/
pm_constant_id_t name;
/**
* InstanceVariableAndWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* InstanceVariableAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* InstanceVariableAndWriteNode#value
*/
struct pm_node *value;
} pm_instance_variable_and_write_node_t;
/**
* InstanceVariableOperatorWriteNode
*
* Represents assigning to an instance variable using an operator that isn't `=`.
*
* @target += value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableOperatorWriteNode#name
*/
pm_constant_id_t name;
/**
* InstanceVariableOperatorWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* InstanceVariableOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* InstanceVariableOperatorWriteNode#value
*/
struct pm_node *value;
/**
* InstanceVariableOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
} pm_instance_variable_operator_write_node_t;
/**
* InstanceVariableOrWriteNode
*
* Represents the use of the `||=` operator for assignment to an instance variable.
*
* @target ||= value
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableOrWriteNode#name
*/
pm_constant_id_t name;
/**
* InstanceVariableOrWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* InstanceVariableOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* InstanceVariableOrWriteNode#value
*/
struct pm_node *value;
} pm_instance_variable_or_write_node_t;
/**
* InstanceVariableReadNode
*
* Represents referencing an instance variable.
*
* @foo
* ^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableReadNode#name
*
* The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* @x # name `:@x`
*
* @_test # name `:@_test`
*/
pm_constant_id_t name;
} pm_instance_variable_read_node_t;
/**
* InstanceVariableTargetNode
*
* Represents writing to an instance variable in a context that doesn't have an explicit value.
*
* @foo, @bar = baz
* ^^^^ ^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableTargetNode#name
*/
pm_constant_id_t name;
} pm_instance_variable_target_node_t;
/**
* InstanceVariableWriteNode
*
* Represents writing to an instance variable.
*
* @foo = 1
* ^^^^^^^^
*
* Type: ::PM_INSTANCE_VARIABLE_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_instance_variable_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* InstanceVariableWriteNode#name
*
* The name of the instance variable, which is a `@` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* @x = :y # name `:@x`
*
* @_foo = "bar" # name `@_foo`
*/
pm_constant_id_t name;
/**
* InstanceVariableWriteNode#name_loc
*
* The location of the variable name.
*
* @_x = 1
* ^^^
*/
pm_location_t name_loc;
/**
* InstanceVariableWriteNode#value
*
* The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* @foo = :bar
* ^^^^
*
* @_x = 1234
* ^^^^
*/
struct pm_node *value;
/**
* InstanceVariableWriteNode#operator_loc
*
* The location of the `=` operator.
*
* @x = y
* ^
*/
pm_location_t operator_loc;
} pm_instance_variable_write_node_t;
/**
* IntegerNode
*
* Represents an integer number literal.
*
* 1
* ^
*
* Type: ::PM_INTEGER_NODE
* Flags (#pm_integer_base_flags):
* * ::PM_INTEGER_BASE_FLAGS_BINARY
* * ::PM_INTEGER_BASE_FLAGS_DECIMAL
* * ::PM_INTEGER_BASE_FLAGS_OCTAL
* * ::PM_INTEGER_BASE_FLAGS_HEXADECIMAL
*
* @extends pm_node_t
*/
typedef struct pm_integer_node {
/** The embedded base node. */
pm_node_t base;
/**
* IntegerNode#value
*
* The value of the integer literal as a number.
*/
pm_integer_t value;
} pm_integer_node_t;
/**
* InterpolatedMatchLastLineNode
*
* 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
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_INTERPOLATED_MATCH_LAST_LINE_NODE
* Flags (#pm_regular_expression_flags):
* * ::PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
* * ::PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
* * ::PM_REGULAR_EXPRESSION_FLAGS_ONCE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
* * ::PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
* * ::PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
* * ::PM_REGULAR_EXPRESSION_FLAGS_UTF_8
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_interpolated_match_last_line_node {
/** The embedded base node. */
pm_node_t base;
/**
* InterpolatedMatchLastLineNode#opening_loc
*/
pm_location_t opening_loc;
/**
* InterpolatedMatchLastLineNode#parts
*/
struct pm_node_list parts;
/**
* InterpolatedMatchLastLineNode#closing_loc
*/
pm_location_t closing_loc;
} pm_interpolated_match_last_line_node_t;
/**
* InterpolatedRegularExpressionNode
*
* Represents a regular expression literal that contains interpolation.
*
* /foo #{bar} baz/
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
* Flags (#pm_regular_expression_flags):
* * ::PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
* * ::PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
* * ::PM_REGULAR_EXPRESSION_FLAGS_ONCE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
* * ::PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
* * ::PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
* * ::PM_REGULAR_EXPRESSION_FLAGS_UTF_8
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_interpolated_regular_expression_node {
/** The embedded base node. */
pm_node_t base;
/**
* InterpolatedRegularExpressionNode#opening_loc
*/
pm_location_t opening_loc;
/**
* InterpolatedRegularExpressionNode#parts
*/
struct pm_node_list parts;
/**
* InterpolatedRegularExpressionNode#closing_loc
*/
pm_location_t closing_loc;
} pm_interpolated_regular_expression_node_t;
/**
* InterpolatedStringNode
*
* Represents a string literal that contains interpolation.
*
* "foo #{bar} baz"
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_INTERPOLATED_STRING_NODE
* Flags (#pm_interpolated_string_node_flags):
* * ::PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN
* * ::PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE
*
* @extends pm_node_t
*/
typedef struct pm_interpolated_string_node {
/** The embedded base node. */
pm_node_t base;
/**
* InterpolatedStringNode#opening_loc
*/
pm_location_t opening_loc;
/**
* InterpolatedStringNode#parts
*/
struct pm_node_list parts;
/**
* InterpolatedStringNode#closing_loc
*/
pm_location_t closing_loc;
} pm_interpolated_string_node_t;
/**
* InterpolatedSymbolNode
*
* Represents a symbol literal that contains interpolation.
*
* :"foo #{bar} baz"
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_INTERPOLATED_SYMBOL_NODE
*
* @extends pm_node_t
*/
typedef struct pm_interpolated_symbol_node {
/** The embedded base node. */
pm_node_t base;
/**
* InterpolatedSymbolNode#opening_loc
*/
pm_location_t opening_loc;
/**
* InterpolatedSymbolNode#parts
*/
struct pm_node_list parts;
/**
* InterpolatedSymbolNode#closing_loc
*/
pm_location_t closing_loc;
} pm_interpolated_symbol_node_t;
/**
* InterpolatedXStringNode
*
* Represents an xstring literal that contains interpolation.
*
* `foo #{bar} baz`
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_INTERPOLATED_X_STRING_NODE
*
* @extends pm_node_t
*/
typedef struct pm_interpolated_x_string_node {
/** The embedded base node. */
pm_node_t base;
/**
* InterpolatedXStringNode#opening_loc
*/
pm_location_t opening_loc;
/**
* InterpolatedXStringNode#parts
*/
struct pm_node_list parts;
/**
* InterpolatedXStringNode#closing_loc
*/
pm_location_t closing_loc;
} pm_interpolated_x_string_node_t;
/**
* ItLocalVariableReadNode
*
* Represents reading from the implicit `it` local variable.
*
* -> { it }
* ^^
*
* Type: ::PM_IT_LOCAL_VARIABLE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_it_local_variable_read_node {
/** The embedded base node. */
pm_node_t base;
} pm_it_local_variable_read_node_t;
/**
* ItParametersNode
*
* Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
*
* -> { it + it }
* ^^^^^^^^^^^^^^
*
* Type: ::PM_IT_PARAMETERS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_it_parameters_node {
/** The embedded base node. */
pm_node_t base;
} pm_it_parameters_node_t;
/**
* KeywordHashNode
*
* Represents a hash literal without opening and closing braces.
*
* foo(a: b)
* ^^^^
*
* Type: ::PM_KEYWORD_HASH_NODE
* Flags (#pm_keyword_hash_node_flags):
* * ::PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS
*
* @extends pm_node_t
*/
typedef struct pm_keyword_hash_node {
/** The embedded base node. */
pm_node_t base;
/**
* KeywordHashNode#elements
*/
struct pm_node_list elements;
} pm_keyword_hash_node_t;
/**
* KeywordRestParameterNode
*
* Represents a keyword rest parameter to a method, block, or lambda definition.
*
* def a(**b)
* ^^^
* end
*
* Type: ::PM_KEYWORD_REST_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_keyword_rest_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* KeywordRestParameterNode#name
*/
pm_constant_id_t name;
/**
* KeywordRestParameterNode#name_loc
*/
pm_location_t name_loc;
/**
* KeywordRestParameterNode#operator_loc
*/
pm_location_t operator_loc;
} pm_keyword_rest_parameter_node_t;
/**
* LambdaNode
*
* Represents using a lambda literal (not the lambda method call).
*
* ->(value) { value * 2 }
* ^^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_LAMBDA_NODE
*
* @extends pm_node_t
*/
typedef struct pm_lambda_node {
/** The embedded base node. */
pm_node_t base;
/**
* LambdaNode#locals
*/
pm_constant_id_list_t locals;
/**
* LambdaNode#operator_loc
*/
pm_location_t operator_loc;
/**
* LambdaNode#opening_loc
*/
pm_location_t opening_loc;
/**
* LambdaNode#closing_loc
*/
pm_location_t closing_loc;
/**
* LambdaNode#parameters
*/
struct pm_node *parameters;
/**
* LambdaNode#body
*/
struct pm_node *body;
} pm_lambda_node_t;
/**
* LocalVariableAndWriteNode
*
* Represents the use of the `&&=` operator for assignment to a local variable.
*
* target &&= value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_LOCAL_VARIABLE_AND_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_and_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableAndWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* LocalVariableAndWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* LocalVariableAndWriteNode#value
*/
struct pm_node *value;
/**
* LocalVariableAndWriteNode#name
*/
pm_constant_id_t name;
/**
* LocalVariableAndWriteNode#depth
*/
uint32_t depth;
} pm_local_variable_and_write_node_t;
/**
* LocalVariableOperatorWriteNode
*
* Represents assigning to a local variable using an operator that isn't `=`.
*
* target += value
* ^^^^^^^^^^^^^^^
*
* Type: ::PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_operator_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableOperatorWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* LocalVariableOperatorWriteNode#binary_operator_loc
*/
pm_location_t binary_operator_loc;
/**
* LocalVariableOperatorWriteNode#value
*/
struct pm_node *value;
/**
* LocalVariableOperatorWriteNode#name
*/
pm_constant_id_t name;
/**
* LocalVariableOperatorWriteNode#binary_operator
*/
pm_constant_id_t binary_operator;
/**
* LocalVariableOperatorWriteNode#depth
*/
uint32_t depth;
} pm_local_variable_operator_write_node_t;
/**
* LocalVariableOrWriteNode
*
* Represents the use of the `||=` operator for assignment to a local variable.
*
* target ||= value
* ^^^^^^^^^^^^^^^^
*
* Type: ::PM_LOCAL_VARIABLE_OR_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_or_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableOrWriteNode#name_loc
*/
pm_location_t name_loc;
/**
* LocalVariableOrWriteNode#operator_loc
*/
pm_location_t operator_loc;
/**
* LocalVariableOrWriteNode#value
*/
struct pm_node *value;
/**
* LocalVariableOrWriteNode#name
*/
pm_constant_id_t name;
/**
* LocalVariableOrWriteNode#depth
*/
uint32_t depth;
} pm_local_variable_or_write_node_t;
/**
* LocalVariableReadNode
*
* 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
* ^^^
*
* Type: ::PM_LOCAL_VARIABLE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableReadNode#name
*
* The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* x # name `:x`
*
* _Test # name `:_Test`
*
* Note that this can also be an underscore followed by a number for the default block parameters.
*
* _1 # name `:_1`
*/
pm_constant_id_t name;
/**
* LocalVariableReadNode#depth
*
* The number of visible scopes that should be searched to find the origin of this local variable.
*
* foo = 1; foo # depth 0
*
* bar = 2; tap { bar } # depth 1
*
* The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
*/
uint32_t depth;
} pm_local_variable_read_node_t;
/**
* LocalVariableTargetNode
*
* Represents writing to a local variable in a context that doesn't have an explicit value.
*
* foo, bar = baz
* ^^^ ^^^
*
* foo => baz
* ^^^
*
* Type: ::PM_LOCAL_VARIABLE_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableTargetNode#name
*/
pm_constant_id_t name;
/**
* LocalVariableTargetNode#depth
*/
uint32_t depth;
} pm_local_variable_target_node_t;
/**
* LocalVariableWriteNode
*
* Represents writing to a local variable.
*
* foo = 1
* ^^^^^^^
*
* Type: ::PM_LOCAL_VARIABLE_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_local_variable_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* LocalVariableWriteNode#name
*
* The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
*
* foo = :bar # name `:foo`
*
* abc = 123 # name `:abc`
*/
pm_constant_id_t name;
/**
* LocalVariableWriteNode#depth
*
* The number of semantic scopes we have to traverse to find the declaration of this variable.
*
* foo = 1 # depth 0
*
* tap { foo = 1 } # depth 1
*
* The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
*/
uint32_t depth;
/**
* LocalVariableWriteNode#name_loc
*
* The location of the variable name.
*
* foo = :bar
* ^^^
*/
pm_location_t name_loc;
/**
* LocalVariableWriteNode#value
*
* The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* foo = :bar
* ^^^^
*
* abc = 1234
* ^^^^
*
* Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
*
* foo = foo
*/
struct pm_node *value;
/**
* LocalVariableWriteNode#operator_loc
*
* The location of the `=` operator.
*
* x = :y
* ^
*/
pm_location_t operator_loc;
} pm_local_variable_write_node_t;
/**
* MatchLastLineNode
*
* 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
* ^^^^^^
*
* Type: ::PM_MATCH_LAST_LINE_NODE
* Flags (#pm_regular_expression_flags):
* * ::PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
* * ::PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
* * ::PM_REGULAR_EXPRESSION_FLAGS_ONCE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
* * ::PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
* * ::PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
* * ::PM_REGULAR_EXPRESSION_FLAGS_UTF_8
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_match_last_line_node {
/** The embedded base node. */
pm_node_t base;
/**
* MatchLastLineNode#opening_loc
*/
pm_location_t opening_loc;
/**
* MatchLastLineNode#content_loc
*/
pm_location_t content_loc;
/**
* MatchLastLineNode#closing_loc
*/
pm_location_t closing_loc;
/**
* MatchLastLineNode#unescaped
*/
pm_string_t unescaped;
} pm_match_last_line_node_t;
/**
* MatchPredicateNode
*
* Represents the use of the modifier `in` operator.
*
* foo in bar
* ^^^^^^^^^^
*
* Type: ::PM_MATCH_PREDICATE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_match_predicate_node {
/** The embedded base node. */
pm_node_t base;
/**
* MatchPredicateNode#value
*/
struct pm_node *value;
/**
* MatchPredicateNode#pattern
*/
struct pm_node *pattern;
/**
* MatchPredicateNode#operator_loc
*/
pm_location_t operator_loc;
} pm_match_predicate_node_t;
/**
* MatchRequiredNode
*
* Represents the use of the `=>` operator.
*
* foo => bar
* ^^^^^^^^^^
*
* Type: ::PM_MATCH_REQUIRED_NODE
*
* @extends pm_node_t
*/
typedef struct pm_match_required_node {
/** The embedded base node. */
pm_node_t base;
/**
* MatchRequiredNode#value
*
* Represents the left-hand side of the operator.
*
* foo => bar
* ^^^
*/
struct pm_node *value;
/**
* MatchRequiredNode#pattern
*
* Represents the right-hand side of the operator. The type of the node depends on the expression.
*
* Anything that looks like a local variable name (including `_`) will result in a `LocalVariableTargetNode`.
*
* foo => a # This is equivalent to writing `a = foo`
* ^
*
* Using an explicit `Array` or combining expressions with `,` will result in a `ArrayPatternNode`. This can be preceded by a constant.
*
* foo => [a]
* ^^^
*
* foo => a, b
* ^^^^
*
* foo => Bar[a, b]
* ^^^^^^^^^
*
* If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead.
*
* foo => *, 1, *a
* ^^^^^
*
* Using an explicit `Hash` or a constant with square brackets and hash keys in the square brackets will result in a `HashPatternNode`.
*
* foo => { a: 1, b: }
*
* foo => Bar[a: 1, b:]
*
* foo => Bar[**]
*
* To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode`
*
* foo => ^a
* ^^
*
* Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`.
*
* foo => ^(a + 1)
*
* Anything else will result in the regular node for that expression, for example a `ConstantReadNode`.
*
* foo => CONST
*/
struct pm_node *pattern;
/**
* MatchRequiredNode#operator_loc
*
* The location of the operator.
*
* foo => bar
* ^^
*/
pm_location_t operator_loc;
} pm_match_required_node_t;
/**
* MatchWriteNode
*
* Represents writing local variables using a regular expression match with named capture groups.
*
* /(?<foo>bar)/ =~ baz
* ^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_MATCH_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_match_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* MatchWriteNode#call
*/
struct pm_call_node *call;
/**
* MatchWriteNode#targets
*/
struct pm_node_list targets;
} pm_match_write_node_t;
/**
* MissingNode
*
* Represents a node that is missing from the source and results in a syntax error.
*
* Type: ::PM_MISSING_NODE
*
* @extends pm_node_t
*/
typedef struct pm_missing_node {
/** The embedded base node. */
pm_node_t base;
} pm_missing_node_t;
/**
* ModuleNode
*
* Represents a module declaration involving the `module` keyword.
*
* module Foo end
* ^^^^^^^^^^^^^^
*
* Type: ::PM_MODULE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_module_node {
/** The embedded base node. */
pm_node_t base;
/**
* ModuleNode#locals
*/
pm_constant_id_list_t locals;
/**
* ModuleNode#module_keyword_loc
*/
pm_location_t module_keyword_loc;
/**
* ModuleNode#constant_path
*/
struct pm_node *constant_path;
/**
* ModuleNode#body
*/
struct pm_node *body;
/**
* ModuleNode#end_keyword_loc
*/
pm_location_t end_keyword_loc;
/**
* ModuleNode#name
*/
pm_constant_id_t name;
} pm_module_node_t;
/**
* MultiTargetNode
*
* 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]]
* ^^^^
*
* Type: ::PM_MULTI_TARGET_NODE
*
* @extends pm_node_t
*/
typedef struct pm_multi_target_node {
/** The embedded base node. */
pm_node_t base;
/**
* MultiTargetNode#lefts
*
* Represents the targets expressions before a splat node.
*
* a, (b, c, *) = 1, 2, 3, 4, 5
* ^^^^
*
* The splat node can be absent, in that case all target expressions are in the left field.
*
* a, (b, c) = 1, 2, 3, 4, 5
* ^^^^
*/
struct pm_node_list lefts;
/**
* MultiTargetNode#rest
*
* Represents a splat node in the target expression.
*
* a, (b, *c) = 1, 2, 3, 4
* ^^
*
* The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
*
* a, (b, *) = 1, 2, 3, 4
* ^
*
* If the `*` is omitted, this field will contain an `ImplicitRestNode`
*
* a, (b,) = 1, 2, 3, 4
* ^
*/
struct pm_node *rest;
/**
* MultiTargetNode#rights
*
* Represents the targets expressions after a splat node.
*
* a, (*, b, c) = 1, 2, 3, 4, 5
* ^^^^
*/
struct pm_node_list rights;
/**
* MultiTargetNode#lparen_loc
*
* The location of the opening parenthesis.
*
* a, (b, c) = 1, 2, 3
* ^
*/
pm_location_t lparen_loc;
/**
* MultiTargetNode#rparen_loc
*
* The location of the closing parenthesis.
*
* a, (b, c) = 1, 2, 3
* ^
*/
pm_location_t rparen_loc;
} pm_multi_target_node_t;
/**
* MultiWriteNode
*
* Represents a write to a multi-target expression.
*
* a, b, c = 1, 2, 3
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_MULTI_WRITE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_multi_write_node {
/** The embedded base node. */
pm_node_t base;
/**
* MultiWriteNode#lefts
*
* Represents the targets expressions before a splat node.
*
* a, b, * = 1, 2, 3, 4, 5
* ^^^^
*
* The splat node can be absent, in that case all target expressions are in the left field.
*
* a, b, c = 1, 2, 3, 4, 5
* ^^^^^^^
*/
struct pm_node_list lefts;
/**
* MultiWriteNode#rest
*
* Represents a splat node in the target expression.
*
* a, b, *c = 1, 2, 3, 4
* ^^
*
* The variable can be empty, this results in a `SplatNode` with a `nil` expression field.
*
* a, b, * = 1, 2, 3, 4
* ^
*
* If the `*` is omitted, this field will contain an `ImplicitRestNode`
*
* a, b, = 1, 2, 3, 4
* ^
*/
struct pm_node *rest;
/**
* MultiWriteNode#rights
*
* Represents the targets expressions after a splat node.
*
* a, *, b, c = 1, 2, 3, 4, 5
* ^^^^
*/
struct pm_node_list rights;
/**
* MultiWriteNode#lparen_loc
*
* The location of the opening parenthesis.
*
* (a, b, c) = 1, 2, 3
* ^
*/
pm_location_t lparen_loc;
/**
* MultiWriteNode#rparen_loc
*
* The location of the closing parenthesis.
*
* (a, b, c) = 1, 2, 3
* ^
*/
pm_location_t rparen_loc;
/**
* MultiWriteNode#operator_loc
*
* The location of the operator.
*
* a, b, c = 1, 2, 3
* ^
*/
pm_location_t operator_loc;
/**
* MultiWriteNode#value
*
* The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* a, b, c = 1, 2, 3
* ^^^^^^^
*/
struct pm_node *value;
} pm_multi_write_node_t;
/**
* NextNode
*
* Represents the use of the `next` keyword.
*
* next 1
* ^^^^^^
*
* Type: ::PM_NEXT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_next_node {
/** The embedded base node. */
pm_node_t base;
/**
* NextNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* NextNode#keyword_loc
*/
pm_location_t keyword_loc;
} pm_next_node_t;
/**
* NilNode
*
* Represents the use of the `nil` keyword.
*
* nil
* ^^^
*
* Type: ::PM_NIL_NODE
*
* @extends pm_node_t
*/
typedef struct pm_nil_node {
/** The embedded base node. */
pm_node_t base;
} pm_nil_node_t;
/**
* NoKeywordsParameterNode
*
* Represents the use of `**nil` inside method arguments.
*
* def a(**nil)
* ^^^^^
* end
*
* Type: ::PM_NO_KEYWORDS_PARAMETER_NODE
*
* @extends pm_node_t
*/
typedef struct pm_no_keywords_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* NoKeywordsParameterNode#operator_loc
*/
pm_location_t operator_loc;
/**
* NoKeywordsParameterNode#keyword_loc
*/
pm_location_t keyword_loc;
} pm_no_keywords_parameter_node_t;
/**
* NumberedParametersNode
*
* Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
*
* -> { _1 + _2 }
* ^^^^^^^^^^^^^^
*
* Type: ::PM_NUMBERED_PARAMETERS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_numbered_parameters_node {
/** The embedded base node. */
pm_node_t base;
/**
* NumberedParametersNode#maximum
*/
uint8_t maximum;
} pm_numbered_parameters_node_t;
/**
* NumberedReferenceReadNode
*
* Represents reading a numbered reference to a capture in the previous match.
*
* $1
* ^^
*
* Type: ::PM_NUMBERED_REFERENCE_READ_NODE
*
* @extends pm_node_t
*/
typedef struct pm_numbered_reference_read_node {
/** The embedded base node. */
pm_node_t base;
/**
* NumberedReferenceReadNode#number
*
* The (1-indexed, from the left) number of the capture group. Numbered references that are too large result in this value being `0`.
*
* $1 # number `1`
*
* $5432 # number `5432`
*
* $4294967296 # number `0`
*/
uint32_t number;
} pm_numbered_reference_read_node_t;
/**
* OptionalKeywordParameterNode
*
* Represents an optional keyword parameter to a method, block, or lambda definition.
*
* def a(b: 1)
* ^^^^
* end
*
* Type: ::PM_OPTIONAL_KEYWORD_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_optional_keyword_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* OptionalKeywordParameterNode#name
*/
pm_constant_id_t name;
/**
* OptionalKeywordParameterNode#name_loc
*/
pm_location_t name_loc;
/**
* OptionalKeywordParameterNode#value
*/
struct pm_node *value;
} pm_optional_keyword_parameter_node_t;
/**
* OptionalParameterNode
*
* Represents an optional parameter to a method, block, or lambda definition.
*
* def a(b = 1)
* ^^^^^
* end
*
* Type: ::PM_OPTIONAL_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_optional_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* OptionalParameterNode#name
*/
pm_constant_id_t name;
/**
* OptionalParameterNode#name_loc
*/
pm_location_t name_loc;
/**
* OptionalParameterNode#operator_loc
*/
pm_location_t operator_loc;
/**
* OptionalParameterNode#value
*/
struct pm_node *value;
} pm_optional_parameter_node_t;
/**
* OrNode
*
* Represents the use of the `||` operator or the `or` keyword.
*
* left or right
* ^^^^^^^^^^^^^
*
* Type: ::PM_OR_NODE
*
* @extends pm_node_t
*/
typedef struct pm_or_node {
/** The embedded base node. */
pm_node_t base;
/**
* OrNode#left
*
* Represents the left side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* left or right
* ^^^^
*
* 1 || 2
* ^
*/
struct pm_node *left;
/**
* OrNode#right
*
* Represents the right side of the expression.
*
* left || right
* ^^^^^
*
* 1 or 2
* ^
*/
struct pm_node *right;
/**
* OrNode#operator_loc
*
* The location of the `or` keyword or the `||` operator.
*
* left or right
* ^^
*/
pm_location_t operator_loc;
} pm_or_node_t;
/**
* ParametersNode
*
* Represents the list of parameters on a method, block, or lambda definition.
*
* def a(b, c, d)
* ^^^^^^^
* end
*
* Type: ::PM_PARAMETERS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_parameters_node {
/** The embedded base node. */
pm_node_t base;
/**
* ParametersNode#requireds
*/
struct pm_node_list requireds;
/**
* ParametersNode#optionals
*/
struct pm_node_list optionals;
/**
* ParametersNode#rest
*/
struct pm_node *rest;
/**
* ParametersNode#posts
*/
struct pm_node_list posts;
/**
* ParametersNode#keywords
*/
struct pm_node_list keywords;
/**
* ParametersNode#keyword_rest
*/
struct pm_node *keyword_rest;
/**
* ParametersNode#block
*/
struct pm_block_parameter_node *block;
} pm_parameters_node_t;
/**
* ParenthesesNode
*
* Represents a parenthesized expression
*
* (10 + 34)
* ^^^^^^^^^
*
* Type: ::PM_PARENTHESES_NODE
* Flags (#pm_parentheses_node_flags):
* * ::PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS
*
* @extends pm_node_t
*/
typedef struct pm_parentheses_node {
/** The embedded base node. */
pm_node_t base;
/**
* ParenthesesNode#body
*/
struct pm_node *body;
/**
* ParenthesesNode#opening_loc
*/
pm_location_t opening_loc;
/**
* ParenthesesNode#closing_loc
*/
pm_location_t closing_loc;
} pm_parentheses_node_t;
/**
* PinnedExpressionNode
*
* Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
*
* foo in ^(bar)
* ^^^^^^
*
* Type: ::PM_PINNED_EXPRESSION_NODE
*
* @extends pm_node_t
*/
typedef struct pm_pinned_expression_node {
/** The embedded base node. */
pm_node_t base;
/**
* PinnedExpressionNode#expression
*
* The expression used in the pinned expression
*
* foo in ^(bar)
* ^^^
*/
struct pm_node *expression;
/**
* PinnedExpressionNode#operator_loc
*
* The location of the `^` operator
*
* foo in ^(bar)
* ^
*/
pm_location_t operator_loc;
/**
* PinnedExpressionNode#lparen_loc
*
* The location of the opening parenthesis.
*
* foo in ^(bar)
* ^
*/
pm_location_t lparen_loc;
/**
* PinnedExpressionNode#rparen_loc
*
* The location of the closing parenthesis.
*
* foo in ^(bar)
* ^
*/
pm_location_t rparen_loc;
} pm_pinned_expression_node_t;
/**
* PinnedVariableNode
*
* Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
*
* foo in ^bar
* ^^^^
*
* Type: ::PM_PINNED_VARIABLE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_pinned_variable_node {
/** The embedded base node. */
pm_node_t base;
/**
* PinnedVariableNode#variable
*
* The variable used in the pinned expression
*
* foo in ^bar
* ^^^
*/
struct pm_node *variable;
/**
* PinnedVariableNode#operator_loc
*
* The location of the `^` operator
*
* foo in ^bar
* ^
*/
pm_location_t operator_loc;
} pm_pinned_variable_node_t;
/**
* PostExecutionNode
*
* Represents the use of the `END` keyword.
*
* END { foo }
* ^^^^^^^^^^^
*
* Type: ::PM_POST_EXECUTION_NODE
*
* @extends pm_node_t
*/
typedef struct pm_post_execution_node {
/** The embedded base node. */
pm_node_t base;
/**
* PostExecutionNode#statements
*/
struct pm_statements_node *statements;
/**
* PostExecutionNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* PostExecutionNode#opening_loc
*/
pm_location_t opening_loc;
/**
* PostExecutionNode#closing_loc
*/
pm_location_t closing_loc;
} pm_post_execution_node_t;
/**
* PreExecutionNode
*
* Represents the use of the `BEGIN` keyword.
*
* BEGIN { foo }
* ^^^^^^^^^^^^^
*
* Type: ::PM_PRE_EXECUTION_NODE
*
* @extends pm_node_t
*/
typedef struct pm_pre_execution_node {
/** The embedded base node. */
pm_node_t base;
/**
* PreExecutionNode#statements
*/
struct pm_statements_node *statements;
/**
* PreExecutionNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* PreExecutionNode#opening_loc
*/
pm_location_t opening_loc;
/**
* PreExecutionNode#closing_loc
*/
pm_location_t closing_loc;
} pm_pre_execution_node_t;
/**
* ProgramNode
*
* The top level node of any parse tree.
*
* Type: ::PM_PROGRAM_NODE
*
* @extends pm_node_t
*/
typedef struct pm_program_node {
/** The embedded base node. */
pm_node_t base;
/**
* ProgramNode#locals
*/
pm_constant_id_list_t locals;
/**
* ProgramNode#statements
*/
struct pm_statements_node *statements;
} pm_program_node_t;
/**
* RangeNode
*
* Represents the use of the `..` or `...` operators.
*
* 1..2
* ^^^^
*
* c if a =~ /left/ ... b =~ /right/
* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_RANGE_NODE
* Flags (#pm_range_flags):
* * ::PM_RANGE_FLAGS_EXCLUDE_END
*
* @extends pm_node_t
*/
typedef struct pm_range_node {
/** The embedded base node. */
pm_node_t base;
/**
* RangeNode#left
*
* The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* 1...
* ^
*
* hello...goodbye
* ^^^^^
*/
struct pm_node *left;
/**
* RangeNode#right
*
* The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* ..5
* ^
*
* 1...foo
* ^^^
* If neither right-hand or left-hand side was included, this will be a MissingNode.
*/
struct pm_node *right;
/**
* RangeNode#operator_loc
*
* The location of the `..` or `...` operator.
*/
pm_location_t operator_loc;
} pm_range_node_t;
/**
* RationalNode
*
* Represents a rational number literal.
*
* 1.0r
* ^^^^
*
* Type: ::PM_RATIONAL_NODE
* Flags (#pm_integer_base_flags):
* * ::PM_INTEGER_BASE_FLAGS_BINARY
* * ::PM_INTEGER_BASE_FLAGS_DECIMAL
* * ::PM_INTEGER_BASE_FLAGS_OCTAL
* * ::PM_INTEGER_BASE_FLAGS_HEXADECIMAL
*
* @extends pm_node_t
*/
typedef struct pm_rational_node {
/** The embedded base node. */
pm_node_t base;
/**
* RationalNode#numerator
*
* The numerator of the rational number.
*
* 1.5r # numerator 3
*/
pm_integer_t numerator;
/**
* RationalNode#denominator
*
* The denominator of the rational number.
*
* 1.5r # denominator 2
*/
pm_integer_t denominator;
} pm_rational_node_t;
/**
* RedoNode
*
* Represents the use of the `redo` keyword.
*
* redo
* ^^^^
*
* Type: ::PM_REDO_NODE
*
* @extends pm_node_t
*/
typedef struct pm_redo_node {
/** The embedded base node. */
pm_node_t base;
} pm_redo_node_t;
/**
* RegularExpressionNode
*
* Represents a regular expression literal with no interpolation.
*
* /foo/i
* ^^^^^^
*
* Type: ::PM_REGULAR_EXPRESSION_NODE
* Flags (#pm_regular_expression_flags):
* * ::PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
* * ::PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
* * ::PM_REGULAR_EXPRESSION_FLAGS_ONCE
* * ::PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
* * ::PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
* * ::PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
* * ::PM_REGULAR_EXPRESSION_FLAGS_UTF_8
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_regular_expression_node {
/** The embedded base node. */
pm_node_t base;
/**
* RegularExpressionNode#opening_loc
*/
pm_location_t opening_loc;
/**
* RegularExpressionNode#content_loc
*/
pm_location_t content_loc;
/**
* RegularExpressionNode#closing_loc
*/
pm_location_t closing_loc;
/**
* RegularExpressionNode#unescaped
*/
pm_string_t unescaped;
} pm_regular_expression_node_t;
/**
* RequiredKeywordParameterNode
*
* Represents a required keyword parameter to a method, block, or lambda definition.
*
* def a(b: )
* ^^
* end
*
* Type: ::PM_REQUIRED_KEYWORD_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_required_keyword_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* RequiredKeywordParameterNode#name
*/
pm_constant_id_t name;
/**
* RequiredKeywordParameterNode#name_loc
*/
pm_location_t name_loc;
} pm_required_keyword_parameter_node_t;
/**
* RequiredParameterNode
*
* Represents a required parameter to a method, block, or lambda definition.
*
* def a(b)
* ^
* end
*
* Type: ::PM_REQUIRED_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_required_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* RequiredParameterNode#name
*/
pm_constant_id_t name;
} pm_required_parameter_node_t;
/**
* RescueModifierNode
*
* Represents an expression modified with a rescue.
*
* foo rescue nil
* ^^^^^^^^^^^^^^
*
* Type: ::PM_RESCUE_MODIFIER_NODE
*
* @extends pm_node_t
*/
typedef struct pm_rescue_modifier_node {
/** The embedded base node. */
pm_node_t base;
/**
* RescueModifierNode#expression
*/
struct pm_node *expression;
/**
* RescueModifierNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* RescueModifierNode#rescue_expression
*/
struct pm_node *rescue_expression;
} pm_rescue_modifier_node_t;
/**
* RescueNode
*
* 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.
*
* Type: ::PM_RESCUE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_rescue_node {
/** The embedded base node. */
pm_node_t base;
/**
* RescueNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* RescueNode#exceptions
*/
struct pm_node_list exceptions;
/**
* RescueNode#operator_loc
*/
pm_location_t operator_loc;
/**
* RescueNode#reference
*/
struct pm_node *reference;
/**
* RescueNode#then_keyword_loc
*/
pm_location_t then_keyword_loc;
/**
* RescueNode#statements
*/
struct pm_statements_node *statements;
/**
* RescueNode#subsequent
*/
struct pm_rescue_node *subsequent;
} pm_rescue_node_t;
/**
* RestParameterNode
*
* Represents a rest parameter to a method, block, or lambda definition.
*
* def a(*b)
* ^^
* end
*
* Type: ::PM_REST_PARAMETER_NODE
* Flags (#pm_parameter_flags):
* * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER
*
* @extends pm_node_t
*/
typedef struct pm_rest_parameter_node {
/** The embedded base node. */
pm_node_t base;
/**
* RestParameterNode#name
*/
pm_constant_id_t name;
/**
* RestParameterNode#name_loc
*/
pm_location_t name_loc;
/**
* RestParameterNode#operator_loc
*/
pm_location_t operator_loc;
} pm_rest_parameter_node_t;
/**
* RetryNode
*
* Represents the use of the `retry` keyword.
*
* retry
* ^^^^^
*
* Type: ::PM_RETRY_NODE
*
* @extends pm_node_t
*/
typedef struct pm_retry_node {
/** The embedded base node. */
pm_node_t base;
} pm_retry_node_t;
/**
* ReturnNode
*
* Represents the use of the `return` keyword.
*
* return 1
* ^^^^^^^^
*
* Type: ::PM_RETURN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_return_node {
/** The embedded base node. */
pm_node_t base;
/**
* ReturnNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* ReturnNode#arguments
*/
struct pm_arguments_node *arguments;
} pm_return_node_t;
/**
* SelfNode
*
* Represents the `self` keyword.
*
* self
* ^^^^
*
* Type: ::PM_SELF_NODE
*
* @extends pm_node_t
*/
typedef struct pm_self_node {
/** The embedded base node. */
pm_node_t base;
} pm_self_node_t;
/**
* ShareableConstantNode
*
* 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 }
* ^^^^^^^^^^^^
*
* Type: ::PM_SHAREABLE_CONSTANT_NODE
* Flags (#pm_shareable_constant_node_flags):
* * ::PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL
* * ::PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING
* * ::PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY
*
* @extends pm_node_t
*/
typedef struct pm_shareable_constant_node {
/** The embedded base node. */
pm_node_t base;
/**
* ShareableConstantNode#write
*
* The constant write that should be modified with the shareability state.
*/
struct pm_node *write;
} pm_shareable_constant_node_t;
/**
* SingletonClassNode
*
* Represents a singleton class declaration involving the `class` keyword.
*
* class << self end
* ^^^^^^^^^^^^^^^^^
*
* Type: ::PM_SINGLETON_CLASS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_singleton_class_node {
/** The embedded base node. */
pm_node_t base;
/**
* SingletonClassNode#locals
*/
pm_constant_id_list_t locals;
/**
* SingletonClassNode#class_keyword_loc
*/
pm_location_t class_keyword_loc;
/**
* SingletonClassNode#operator_loc
*/
pm_location_t operator_loc;
/**
* SingletonClassNode#expression
*/
struct pm_node *expression;
/**
* SingletonClassNode#body
*/
struct pm_node *body;
/**
* SingletonClassNode#end_keyword_loc
*/
pm_location_t end_keyword_loc;
} pm_singleton_class_node_t;
/**
* SourceEncodingNode
*
* Represents the use of the `__ENCODING__` keyword.
*
* __ENCODING__
* ^^^^^^^^^^^^
*
* Type: ::PM_SOURCE_ENCODING_NODE
*
* @extends pm_node_t
*/
typedef struct pm_source_encoding_node {
/** The embedded base node. */
pm_node_t base;
} pm_source_encoding_node_t;
/**
* SourceFileNode
*
* Represents the use of the `__FILE__` keyword.
*
* __FILE__
* ^^^^^^^^
*
* Type: ::PM_SOURCE_FILE_NODE
* Flags (#pm_string_flags):
* * ::PM_STRING_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_STRING_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_STRING_FLAGS_FROZEN
* * ::PM_STRING_FLAGS_MUTABLE
*
* @extends pm_node_t
*/
typedef struct pm_source_file_node {
/** The embedded base node. */
pm_node_t base;
/**
* SourceFileNode#filepath
*
* Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
*/
pm_string_t filepath;
} pm_source_file_node_t;
/**
* SourceLineNode
*
* Represents the use of the `__LINE__` keyword.
*
* __LINE__
* ^^^^^^^^
*
* Type: ::PM_SOURCE_LINE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_source_line_node {
/** The embedded base node. */
pm_node_t base;
} pm_source_line_node_t;
/**
* SplatNode
*
* Represents the use of the splat operator.
*
* [*a]
* ^^
*
* Type: ::PM_SPLAT_NODE
*
* @extends pm_node_t
*/
typedef struct pm_splat_node {
/** The embedded base node. */
pm_node_t base;
/**
* SplatNode#operator_loc
*/
pm_location_t operator_loc;
/**
* SplatNode#expression
*/
struct pm_node *expression;
} pm_splat_node_t;
/**
* StatementsNode
*
* Represents a set of statements contained within some scope.
*
* foo; bar; baz
* ^^^^^^^^^^^^^
*
* Type: ::PM_STATEMENTS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_statements_node {
/** The embedded base node. */
pm_node_t base;
/**
* StatementsNode#body
*/
struct pm_node_list body;
} pm_statements_node_t;
/**
* StringNode
*
* 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"
* ^^^^ ^^^^
*
* Type: ::PM_STRING_NODE
* Flags (#pm_string_flags):
* * ::PM_STRING_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_STRING_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_STRING_FLAGS_FROZEN
* * ::PM_STRING_FLAGS_MUTABLE
*
* @extends pm_node_t
*/
typedef struct pm_string_node {
/** The embedded base node. */
pm_node_t base;
/**
* StringNode#opening_loc
*/
pm_location_t opening_loc;
/**
* StringNode#content_loc
*/
pm_location_t content_loc;
/**
* StringNode#closing_loc
*/
pm_location_t closing_loc;
/**
* StringNode#unescaped
*/
pm_string_t unescaped;
} pm_string_node_t;
/**
* SuperNode
*
* 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.
*
* Type: ::PM_SUPER_NODE
*
* @extends pm_node_t
*/
typedef struct pm_super_node {
/** The embedded base node. */
pm_node_t base;
/**
* SuperNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* SuperNode#lparen_loc
*/
pm_location_t lparen_loc;
/**
* SuperNode#arguments
*
* Can be only `nil` when there are empty parentheses, like `super()`.
*/
struct pm_arguments_node *arguments;
/**
* SuperNode#rparen_loc
*/
pm_location_t rparen_loc;
/**
* SuperNode#block
*/
struct pm_node *block;
} pm_super_node_t;
/**
* SymbolNode
*
* Represents a symbol literal or a symbol contained within a `%i` list.
*
* :foo
* ^^^^
*
* %i[foo]
* ^^^
*
* Type: ::PM_SYMBOL_NODE
* Flags (#pm_symbol_flags):
* * ::PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING
* * ::PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_symbol_node {
/** The embedded base node. */
pm_node_t base;
/**
* SymbolNode#opening_loc
*/
pm_location_t opening_loc;
/**
* SymbolNode#value_loc
*/
pm_location_t value_loc;
/**
* SymbolNode#closing_loc
*/
pm_location_t closing_loc;
/**
* SymbolNode#unescaped
*/
pm_string_t unescaped;
} pm_symbol_node_t;
/**
* TrueNode
*
* Represents the use of the literal `true` keyword.
*
* true
* ^^^^
*
* Type: ::PM_TRUE_NODE
*
* @extends pm_node_t
*/
typedef struct pm_true_node {
/** The embedded base node. */
pm_node_t base;
} pm_true_node_t;
/**
* UndefNode
*
* Represents the use of the `undef` keyword.
*
* undef :foo, :bar, :baz
* ^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_UNDEF_NODE
*
* @extends pm_node_t
*/
typedef struct pm_undef_node {
/** The embedded base node. */
pm_node_t base;
/**
* UndefNode#names
*/
struct pm_node_list names;
/**
* UndefNode#keyword_loc
*/
pm_location_t keyword_loc;
} pm_undef_node_t;
/**
* UnlessNode
*
* Represents the use of the `unless` keyword, either in the block form or the modifier form.
*
* bar unless foo
* ^^^^^^^^^^^^^^
*
* unless foo then bar end
* ^^^^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_UNLESS_NODE
*
* @extends pm_node_t
*/
typedef struct pm_unless_node {
/** The embedded base node. */
pm_node_t base;
/**
* UnlessNode#keyword_loc
*
* The location of the `unless` keyword.
*
* unless cond then bar end
* ^^^^^^
*
* bar unless cond
* ^^^^^^
*/
pm_location_t keyword_loc;
/**
* UnlessNode#predicate
*
* The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
*
* unless cond then bar end
* ^^^^
*
* bar unless cond
* ^^^^
*/
struct pm_node *predicate;
/**
* UnlessNode#then_keyword_loc
*
* The location of the `then` keyword, if present.
*
* unless cond then bar end
* ^^^^
*/
pm_location_t then_keyword_loc;
/**
* UnlessNode#statements
*
* The body of statements that will executed if the unless condition is
* falsey. Will be `nil` if no body is provided.
*
* unless cond then bar end
* ^^^
*/
struct pm_statements_node *statements;
/**
* UnlessNode#else_clause
*
* The else clause of the unless expression, if present.
*
* unless cond then bar else baz end
* ^^^^^^^^
*/
struct pm_else_node *else_clause;
/**
* UnlessNode#end_keyword_loc
*
* The location of the `end` keyword, if present.
*
* unless cond then bar end
* ^^^
*/
pm_location_t end_keyword_loc;
} pm_unless_node_t;
/**
* UntilNode
*
* Represents the use of the `until` keyword, either in the block form or the modifier form.
*
* bar until foo
* ^^^^^^^^^^^^^
*
* until foo do bar end
* ^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_UNTIL_NODE
* Flags (#pm_loop_flags):
* * ::PM_LOOP_FLAGS_BEGIN_MODIFIER
*
* @extends pm_node_t
*/
typedef struct pm_until_node {
/** The embedded base node. */
pm_node_t base;
/**
* UntilNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* UntilNode#do_keyword_loc
*/
pm_location_t do_keyword_loc;
/**
* UntilNode#closing_loc
*/
pm_location_t closing_loc;
/**
* UntilNode#predicate
*/
struct pm_node *predicate;
/**
* UntilNode#statements
*/
struct pm_statements_node *statements;
} pm_until_node_t;
/**
* WhenNode
*
* Represents the use of the `when` keyword within a case statement.
*
* case true
* when true
* ^^^^^^^^^
* end
*
* Type: ::PM_WHEN_NODE
*
* @extends pm_node_t
*/
typedef struct pm_when_node {
/** The embedded base node. */
pm_node_t base;
/**
* WhenNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* WhenNode#conditions
*/
struct pm_node_list conditions;
/**
* WhenNode#then_keyword_loc
*/
pm_location_t then_keyword_loc;
/**
* WhenNode#statements
*/
struct pm_statements_node *statements;
} pm_when_node_t;
/**
* WhileNode
*
* Represents the use of the `while` keyword, either in the block form or the modifier form.
*
* bar while foo
* ^^^^^^^^^^^^^
*
* while foo do bar end
* ^^^^^^^^^^^^^^^^^^^^
*
* Type: ::PM_WHILE_NODE
* Flags (#pm_loop_flags):
* * ::PM_LOOP_FLAGS_BEGIN_MODIFIER
*
* @extends pm_node_t
*/
typedef struct pm_while_node {
/** The embedded base node. */
pm_node_t base;
/**
* WhileNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* WhileNode#do_keyword_loc
*/
pm_location_t do_keyword_loc;
/**
* WhileNode#closing_loc
*/
pm_location_t closing_loc;
/**
* WhileNode#predicate
*/
struct pm_node *predicate;
/**
* WhileNode#statements
*/
struct pm_statements_node *statements;
} pm_while_node_t;
/**
* XStringNode
*
* Represents an xstring literal with no interpolation.
*
* `foo`
* ^^^^^
*
* Type: ::PM_X_STRING_NODE
* Flags (#pm_encoding_flags):
* * ::PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING
* * ::PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING
*
* @extends pm_node_t
*/
typedef struct pm_x_string_node {
/** The embedded base node. */
pm_node_t base;
/**
* XStringNode#opening_loc
*/
pm_location_t opening_loc;
/**
* XStringNode#content_loc
*/
pm_location_t content_loc;
/**
* XStringNode#closing_loc
*/
pm_location_t closing_loc;
/**
* XStringNode#unescaped
*/
pm_string_t unescaped;
} pm_x_string_node_t;
/**
* YieldNode
*
* Represents the use of the `yield` keyword.
*
* yield 1
* ^^^^^^^
*
* Type: ::PM_YIELD_NODE
*
* @extends pm_node_t
*/
typedef struct pm_yield_node {
/** The embedded base node. */
pm_node_t base;
/**
* YieldNode#keyword_loc
*/
pm_location_t keyword_loc;
/**
* YieldNode#lparen_loc
*/
pm_location_t lparen_loc;
/**
* YieldNode#arguments
*/
struct pm_arguments_node *arguments;
/**
* YieldNode#rparen_loc
*/
pm_location_t rparen_loc;
} pm_yield_node_t;
/**
* Flags for arguments nodes.
*/
typedef enum pm_arguments_node_flags {
/** if the arguments contain forwarding */
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING = 4,
/** if the arguments contain keywords */
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS = 8,
/** if the arguments contain a keyword splat */
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT = 16,
/** if the arguments contain a splat */
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT = 32,
/** if the arguments contain multiple splats */
PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS = 64,
PM_ARGUMENTS_NODE_FLAGS_LAST,
} pm_arguments_node_flags_t;
/**
* Flags for array nodes.
*/
typedef enum pm_array_node_flags {
/** if array contains splat nodes */
PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT = 4,
PM_ARRAY_NODE_FLAGS_LAST,
} pm_array_node_flags_t;
/**
* Flags for call nodes.
*/
typedef enum pm_call_node_flags {
/** &. operator */
PM_CALL_NODE_FLAGS_SAFE_NAVIGATION = 4,
/** a call that could have been a local variable */
PM_CALL_NODE_FLAGS_VARIABLE_CALL = 8,
/** a call that is an attribute write, so the value being written should be returned */
PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE = 16,
/** a call that ignores method visibility */
PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY = 32,
PM_CALL_NODE_FLAGS_LAST,
} pm_call_node_flags_t;
/**
* Flags for nodes that have unescaped content.
*/
typedef enum pm_encoding_flags {
/** internal bytes forced the encoding to UTF-8 */
PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING = 4,
/** internal bytes forced the encoding to binary */
PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING = 8,
PM_ENCODING_FLAGS_LAST,
} pm_encoding_flags_t;
/**
* Flags for integer nodes that correspond to the base of the integer.
*/
typedef enum pm_integer_base_flags {
/** 0b prefix */
PM_INTEGER_BASE_FLAGS_BINARY = 4,
/** 0d or no prefix */
PM_INTEGER_BASE_FLAGS_DECIMAL = 8,
/** 0o or 0 prefix */
PM_INTEGER_BASE_FLAGS_OCTAL = 16,
/** 0x prefix */
PM_INTEGER_BASE_FLAGS_HEXADECIMAL = 32,
PM_INTEGER_BASE_FLAGS_LAST,
} pm_integer_base_flags_t;
/**
* Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
*/
typedef enum pm_interpolated_string_node_flags {
/** frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` */
PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN = 4,
/** mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` */
PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE = 8,
PM_INTERPOLATED_STRING_NODE_FLAGS_LAST,
} pm_interpolated_string_node_flags_t;
/**
* Flags for keyword hash nodes.
*/
typedef enum pm_keyword_hash_node_flags {
/** a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments */
PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS = 4,
PM_KEYWORD_HASH_NODE_FLAGS_LAST,
} pm_keyword_hash_node_flags_t;
/**
* Flags for while and until loop nodes.
*/
typedef enum pm_loop_flags {
/** a loop after a begin statement, so the body is executed first before the condition */
PM_LOOP_FLAGS_BEGIN_MODIFIER = 4,
PM_LOOP_FLAGS_LAST,
} pm_loop_flags_t;
/**
* Flags for parameter nodes.
*/
typedef enum pm_parameter_flags {
/** a parameter name that has been repeated in the method signature */
PM_PARAMETER_FLAGS_REPEATED_PARAMETER = 4,
PM_PARAMETER_FLAGS_LAST,
} pm_parameter_flags_t;
/**
* Flags for parentheses nodes.
*/
typedef enum pm_parentheses_node_flags {
/** parentheses that contain multiple potentially void statements */
PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS = 4,
PM_PARENTHESES_NODE_FLAGS_LAST,
} pm_parentheses_node_flags_t;
/**
* Flags for range and flip-flop nodes.
*/
typedef enum pm_range_flags {
/** ... operator */
PM_RANGE_FLAGS_EXCLUDE_END = 4,
PM_RANGE_FLAGS_LAST,
} pm_range_flags_t;
/**
* Flags for regular expression and match last line nodes.
*/
typedef enum pm_regular_expression_flags {
/** i - ignores the case of characters when matching */
PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE = 4,
/** x - ignores whitespace and allows comments in regular expressions */
PM_REGULAR_EXPRESSION_FLAGS_EXTENDED = 8,
/** m - allows $ to match the end of lines within strings */
PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE = 16,
/** o - only interpolates values into the regular expression once */
PM_REGULAR_EXPRESSION_FLAGS_ONCE = 32,
/** e - forces the EUC-JP encoding */
PM_REGULAR_EXPRESSION_FLAGS_EUC_JP = 64,
/** n - forces the ASCII-8BIT encoding */
PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT = 128,
/** s - forces the Windows-31J encoding */
PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J = 256,
/** u - forces the UTF-8 encoding */
PM_REGULAR_EXPRESSION_FLAGS_UTF_8 = 512,
/** internal bytes forced the encoding to UTF-8 */
PM_REGULAR_EXPRESSION_FLAGS_FORCED_UTF8_ENCODING = 1024,
/** internal bytes forced the encoding to binary */
PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING = 2048,
/** internal bytes forced the encoding to US-ASCII */
PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING = 4096,
PM_REGULAR_EXPRESSION_FLAGS_LAST,
} pm_regular_expression_flags_t;
/**
* Flags for shareable constant nodes.
*/
typedef enum pm_shareable_constant_node_flags {
/** constant writes that should be modified with shareable constant value literal */
PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL = 4,
/** constant writes that should be modified with shareable constant value experimental everything */
PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING = 8,
/** constant writes that should be modified with shareable constant value experimental copy */
PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY = 16,
PM_SHAREABLE_CONSTANT_NODE_FLAGS_LAST,
} pm_shareable_constant_node_flags_t;
/**
* Flags for string nodes.
*/
typedef enum pm_string_flags {
/** internal bytes forced the encoding to UTF-8 */
PM_STRING_FLAGS_FORCED_UTF8_ENCODING = 4,
/** internal bytes forced the encoding to binary */
PM_STRING_FLAGS_FORCED_BINARY_ENCODING = 8,
/** frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` */
PM_STRING_FLAGS_FROZEN = 16,
/** mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` */
PM_STRING_FLAGS_MUTABLE = 32,
PM_STRING_FLAGS_LAST,
} pm_string_flags_t;
/**
* Flags for symbol nodes.
*/
typedef enum pm_symbol_flags {
/** internal bytes forced the encoding to UTF-8 */
PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING = 4,
/** internal bytes forced the encoding to binary */
PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING = 8,
/** internal bytes forced the encoding to US-ASCII */
PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING = 16,
PM_SYMBOL_FLAGS_LAST,
} pm_symbol_flags_t;
/**
* When we're serializing to Java, we want to skip serializing the location
* fields as they won't be used by JRuby or TruffleRuby. This boolean allows us
* to specify that through the environment. It will never be true except for in
* those build systems.
*/
#define PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS 0
#endif