ruby_prism_sys/

bindings.rs

/* Generated by `bundle exec rake cargo:bindings`. Do not edit by hand.
 * prism 2.0.0, bindgen 0.73.2, layout_tests(false)
 * so the file stays portable across pointer widths.
 */
/* automatically generated by rust-bindgen 0.73.2 */

/** A constant id is a unique identifier for a constant in the constant pool.
*/
pub type pm_constant_id_t = u32;
/** A list of nodes in the source, most often used for lists of children.
*/
pub type pm_node_list_t = pm_node_list;
/** 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.
*/
pub type pm_node_type_t = u16;
/** These are the flags embedded in the node struct. We explicitly control the
 size of it here to avoid having the variable-width enum.
*/
pub type pm_node_flags_t = u16;
/** This is the base structure that represents a node in the syntax tree. It is
 embedded into every node type.
*/
pub type pm_node_t = pm_node;
/** AliasGlobalVariableNode

 Represents the use of the `alias` keyword to alias a global variable.

``` ruby
 alias $foo $bar
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_ALIAS_GLOBAL_VARIABLE_NODE

 @extends pm_node_t
*/
pub type pm_alias_global_variable_node_t = pm_alias_global_variable_node;
/** AliasMethodNode

 Represents the use of the `alias` keyword to alias a method.

``` ruby
 alias foo bar
 ^^^^^^^^^^^^^
```

 Type: ::PM_ALIAS_METHOD_NODE

 @extends pm_node_t
*/
pub type pm_alias_method_node_t = pm_alias_method_node;
/** AlternationPatternNode

 Represents an alternation pattern in pattern matching.

``` ruby
 foo => bar | baz
        ^^^^^^^^^
```

 Type: ::PM_ALTERNATION_PATTERN_NODE

 @extends pm_node_t
*/
pub type pm_alternation_pattern_node_t = pm_alternation_pattern_node;
/** AndNode

 Represents the use of the `&&` operator or the `and` keyword.

``` ruby
 left and right
 ^^^^^^^^^^^^^^
```

 Type: ::PM_AND_NODE

 @extends pm_node_t
*/
pub type pm_and_node_t = pm_and_node;
/** ArgumentsNode

 Represents a set of arguments to a method or a keyword.

``` ruby
 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
*/
pub type pm_arguments_node_t = pm_arguments_node;
/** ArrayNode

 Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.

``` ruby
 [1, 2, 3]
 ^^^^^^^^^
```

 Type: ::PM_ARRAY_NODE

 Flags (#pm_array_node_flags):
 * ::PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT

 @extends pm_node_t
*/
pub type pm_array_node_t = pm_array_node;
/** ArrayPatternNode

 Represents an array pattern in pattern matching.

``` ruby
 foo in 1, 2
        ^^^^
```

``` ruby
 foo in [1, 2]
        ^^^^^^
```

``` ruby
 foo in *bar
        ^^^^
```

``` ruby
 foo in Bar[]
        ^^^^^
```

``` ruby
 foo in Bar[1, 2, 3]
        ^^^^^^^^^^^^
```

 Type: ::PM_ARRAY_PATTERN_NODE

 @extends pm_node_t
*/
pub type pm_array_pattern_node_t = pm_array_pattern_node;
/** AssocNode

 Represents a hash key/value pair.

``` ruby
 { a => b }
   ^^^^^^
```

 Type: ::PM_ASSOC_NODE

 @extends pm_node_t
*/
pub type pm_assoc_node_t = pm_assoc_node;
/** AssocSplatNode

 Represents a splat in a hash literal.

``` ruby
 { **foo }
   ^^^^^
```

 Type: ::PM_ASSOC_SPLAT_NODE

 @extends pm_node_t
*/
pub type pm_assoc_splat_node_t = pm_assoc_splat_node;
/** BackReferenceReadNode

 Represents reading a reference to a field in the previous match.

``` ruby
 $'
 ^^
```

 Type: ::PM_BACK_REFERENCE_READ_NODE

 @extends pm_node_t
*/
pub type pm_back_reference_read_node_t = pm_back_reference_read_node;
/** BeginNode

 Represents a begin statement.

``` ruby
 begin
   foo
 end
 ^^^^^
```

 Type: ::PM_BEGIN_NODE

 @extends pm_node_t
*/
pub type pm_begin_node_t = pm_begin_node;
/** BlockArgumentNode

 Represents a block argument using `&`.

``` ruby
 bar(&args)
     ^^^^^
```

 Type: ::PM_BLOCK_ARGUMENT_NODE

 @extends pm_node_t
*/
pub type pm_block_argument_node_t = pm_block_argument_node;
/** BlockLocalVariableNode

 Represents a block local variable.

``` ruby
 a { |; b| }
        ^
```

 Type: ::PM_BLOCK_LOCAL_VARIABLE_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_block_local_variable_node_t = pm_block_local_variable_node;
/** BlockNode

 Represents a block of ruby code.

``` ruby
 [1, 2, 3].each { |i| puts x }
                ^^^^^^^^^^^^^^
```

 Type: ::PM_BLOCK_NODE

 @extends pm_node_t
*/
pub type pm_block_node_t = pm_block_node;
/** BlockParameterNode

 Represents a block parameter of a method, block, or lambda definition.

``` ruby
 def a(&b)
       ^^
 end
```

 Type: ::PM_BLOCK_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_block_parameter_node_t = pm_block_parameter_node;
/** BlockParametersNode

 Represents a block's parameters declaration.

``` ruby
 -> (a, b = 1; local) { }
    ^^^^^^^^^^^^^^^^^
```

``` ruby
 foo do |a, b = 1; local|
        ^^^^^^^^^^^^^^^^^
 end
```

 Type: ::PM_BLOCK_PARAMETERS_NODE

 @extends pm_node_t
*/
pub type pm_block_parameters_node_t = pm_block_parameters_node;
/** BreakNode

 Represents the use of the `break` keyword.

``` ruby
 break foo
 ^^^^^^^^^
```

 Type: ::PM_BREAK_NODE

 @extends pm_node_t
*/
pub type pm_break_node_t = pm_break_node;
/** CallAndWriteNode

 Represents the use of the `&&=` operator on a call.

``` ruby
 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
*/
pub type pm_call_and_write_node_t = pm_call_and_write_node;
/** CallNode

 Represents a method call, in all of the various forms that can take.

``` ruby
 foo
 ^^^
```

``` ruby
 foo()
 ^^^^^
```

``` ruby
 +foo
 ^^^^
```

``` ruby
 foo + bar
 ^^^^^^^^^
```

``` ruby
 foo.bar
 ^^^^^^^
```

``` ruby
 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
*/
pub type pm_call_node_t = pm_call_node;
/** CallOperatorWriteNode

 Represents the use of an assignment operator on a call.

``` ruby
 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
*/
pub type pm_call_operator_write_node_t = pm_call_operator_write_node;
/** CallOrWriteNode

 Represents the use of the `||=` operator on a call.

``` ruby
 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
*/
pub type pm_call_or_write_node_t = pm_call_or_write_node;
/** CallTargetNode

 Represents assigning to a method call.

``` ruby
 foo.bar, = 1
 ^^^^^^^
```

``` ruby
 begin
 rescue => foo.bar
           ^^^^^^^
 end
```

``` ruby
 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
*/
pub type pm_call_target_node_t = pm_call_target_node;
/** CapturePatternNode

 Represents assigning to a local variable in pattern matching.

``` ruby
 foo => [bar => baz]
         ^^^^^^^^^^
```

 Type: ::PM_CAPTURE_PATTERN_NODE

 @extends pm_node_t
*/
pub type pm_capture_pattern_node_t = pm_capture_pattern_node;
/** CaseMatchNode

 Represents the use of a case statement for pattern matching.

``` ruby
 case true
 in false
 end
 ^^^^^^^^^
```

 Type: ::PM_CASE_MATCH_NODE

 @extends pm_node_t
*/
pub type pm_case_match_node_t = pm_case_match_node;
/** CaseNode

 Represents the use of a case statement.

``` ruby
 case true
 when false
 end
 ^^^^^^^^^^
```

 Type: ::PM_CASE_NODE

 @extends pm_node_t
*/
pub type pm_case_node_t = pm_case_node;
/** ClassNode

 Represents a class declaration involving the `class` keyword.

``` ruby
 class Foo end
 ^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_NODE

 @extends pm_node_t
*/
pub type pm_class_node_t = pm_class_node;
/** ClassVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a class variable.

``` ruby
 @@target &&= value
 ^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_and_write_node_t = pm_class_variable_and_write_node;
/** ClassVariableOperatorWriteNode

 Represents assigning to a class variable using an operator that isn't `=`.

``` ruby
 @@target += value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_operator_write_node_t = pm_class_variable_operator_write_node;
/** ClassVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a class variable.

``` ruby
 @@target ||= value
 ^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_or_write_node_t = pm_class_variable_or_write_node;
/** ClassVariableReadNode

 Represents referencing a class variable.

``` ruby
 @@foo
 ^^^^^
```

 Type: ::PM_CLASS_VARIABLE_READ_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_read_node_t = pm_class_variable_read_node;
/** ClassVariableTargetNode

 Represents writing to a class variable in a context that doesn't have an explicit value.

``` ruby
 @@foo, @@bar = baz
 ^^^^^  ^^^^^
```

 Type: ::PM_CLASS_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_target_node_t = pm_class_variable_target_node;
/** ClassVariableWriteNode

 Represents writing to a class variable.

``` ruby
 @@foo = 1
 ^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_class_variable_write_node_t = pm_class_variable_write_node;
/** ConstantAndWriteNode

 Represents the use of the `&&=` operator for assignment to a constant.

``` ruby
 Target &&= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_and_write_node_t = pm_constant_and_write_node;
/** ConstantOperatorWriteNode

 Represents assigning to a constant using an operator that isn't `=`.

``` ruby
 Target += value
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_operator_write_node_t = pm_constant_operator_write_node;
/** ConstantOrWriteNode

 Represents the use of the `||=` operator for assignment to a constant.

``` ruby
 Target ||= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_or_write_node_t = pm_constant_or_write_node;
/** ConstantPathAndWriteNode

 Represents the use of the `&&=` operator for assignment to a constant path.

``` ruby
 Parent::Child &&= value
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_and_write_node_t = pm_constant_path_and_write_node;
/** ConstantPathNode

 Represents accessing a constant through a path of `::` operators.

``` ruby
 Foo::Bar
 ^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_node_t = pm_constant_path_node;
/** ConstantPathOperatorWriteNode

 Represents assigning to a constant path using an operator that isn't `=`.

``` ruby
 Parent::Child += value
 ^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_operator_write_node_t = pm_constant_path_operator_write_node;
/** ConstantPathOrWriteNode

 Represents the use of the `||=` operator for assignment to a constant path.

``` ruby
 Parent::Child ||= value
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_or_write_node_t = pm_constant_path_or_write_node;
/** ConstantPathTargetNode

 Represents writing to a constant path in a context that doesn't have an explicit value.

``` ruby
 Foo::Foo, Bar::Bar = baz
 ^^^^^^^^  ^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_target_node_t = pm_constant_path_target_node;
/** ConstantPathWriteNode

 Represents writing to a constant path.

``` ruby
 ::Foo = 1
 ^^^^^^^^^
```

``` ruby
 Foo::Bar = 1
 ^^^^^^^^^^^^
```

``` ruby
 ::Foo::Bar = 1
 ^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_path_write_node_t = pm_constant_path_write_node;
/** ConstantReadNode

 Represents referencing a constant.

``` ruby
 Foo
 ^^^
```

 Type: ::PM_CONSTANT_READ_NODE

 @extends pm_node_t
*/
pub type pm_constant_read_node_t = pm_constant_read_node;
/** ConstantTargetNode

 Represents writing to a constant in a context that doesn't have an explicit value.

``` ruby
 Foo, Bar = baz
 ^^^  ^^^
```

 Type: ::PM_CONSTANT_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_constant_target_node_t = pm_constant_target_node;
/** ConstantWriteNode

 Represents writing to a constant.

``` ruby
 Foo = 1
 ^^^^^^^
```

 Type: ::PM_CONSTANT_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_constant_write_node_t = pm_constant_write_node;
/** DefNode

 Represents a method definition.

``` ruby
 def method
 end
 ^^^^^^^^^^
```

 Type: ::PM_DEF_NODE

 @extends pm_node_t
*/
pub type pm_def_node_t = pm_def_node;
/** DefinedNode

 Represents the use of the `defined?` keyword.

``` ruby
 defined?(a)
 ^^^^^^^^^^^
```

 Type: ::PM_DEFINED_NODE

 @extends pm_node_t
*/
pub type pm_defined_node_t = pm_defined_node;
/** ElseNode

 Represents an `else` clause in a `case`, `if`, or `unless` statement.

``` ruby
 if a then b else c end
             ^^^^^^^^^^
```

 Type: ::PM_ELSE_NODE

 @extends pm_node_t
*/
pub type pm_else_node_t = pm_else_node;
/** EmbeddedStatementsNode

 Represents an interpolated set of statements.

``` ruby
 "foo #{bar}"
      ^^^^^^
```

 Type: ::PM_EMBEDDED_STATEMENTS_NODE

 @extends pm_node_t
*/
pub type pm_embedded_statements_node_t = pm_embedded_statements_node;
/** EmbeddedVariableNode

 Represents an interpolated variable.

``` ruby
 "foo #@bar"
      ^^^^^
```

 Type: ::PM_EMBEDDED_VARIABLE_NODE

 @extends pm_node_t
*/
pub type pm_embedded_variable_node_t = pm_embedded_variable_node;
/** EnsureNode

 Represents an `ensure` clause in a `begin` statement.

``` ruby
 begin
   foo
 ensure
 ^^^^^^
   bar
 end
```

 Type: ::PM_ENSURE_NODE

 @extends pm_node_t
*/
pub type pm_ensure_node_t = pm_ensure_node;
/** ErrorRecoveryNode

 Represents a node that is either missing or unexpected and results in a syntax error.

 Type: ::PM_ERROR_RECOVERY_NODE

 @extends pm_node_t
*/
pub type pm_error_recovery_node_t = pm_error_recovery_node;
/** FalseNode

 Represents the use of the literal `false` keyword.

``` ruby
 false
 ^^^^^
```

 Type: ::PM_FALSE_NODE

 @extends pm_node_t
*/
pub type pm_false_node_t = pm_false_node;
/** FindPatternNode

 Represents a find pattern in pattern matching.

``` ruby
 foo in *bar, baz, *qux
        ^^^^^^^^^^^^^^^
```

``` ruby
 foo in [*bar, baz, *qux]
        ^^^^^^^^^^^^^^^^^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
        ^^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo => *bar, baz, *qux
        ^^^^^^^^^^^^^^^
```

 Type: ::PM_FIND_PATTERN_NODE

 @extends pm_node_t
*/
pub type pm_find_pattern_node_t = pm_find_pattern_node;
/** FlipFlopNode

 Represents the use of the `..` or `...` operators to create flip flops.

``` ruby
 baz if foo .. bar
        ^^^^^^^^^^
```

 Type: ::PM_FLIP_FLOP_NODE

 Flags (#pm_range_flags):
 * ::PM_RANGE_FLAGS_EXCLUDE_END

 @extends pm_node_t
*/
pub type pm_flip_flop_node_t = pm_flip_flop_node;
/** FloatNode

 Represents a floating point number literal.

``` ruby
 1.0
 ^^^
```

 Type: ::PM_FLOAT_NODE

 @extends pm_node_t
*/
pub type pm_float_node_t = pm_float_node;
/** ForNode

 Represents the use of the `for` keyword.

``` ruby
 for i in a end
 ^^^^^^^^^^^^^^
```

 Type: ::PM_FOR_NODE

 @extends pm_node_t
*/
pub type pm_for_node_t = pm_for_node;
/** ForwardingArgumentsNode

 Represents forwarding all arguments to this method to another method.

``` ruby
 def foo(...)
   bar(...)
       ^^^
 end
```

 Type: ::PM_FORWARDING_ARGUMENTS_NODE

 @extends pm_node_t
*/
pub type pm_forwarding_arguments_node_t = pm_forwarding_arguments_node;
/** ForwardingParameterNode

 Represents the use of the forwarding parameter in a method, block, or lambda declaration.

``` ruby
 def foo(...)
         ^^^
 end
```

 Type: ::PM_FORWARDING_PARAMETER_NODE

 @extends pm_node_t
*/
pub type pm_forwarding_parameter_node_t = pm_forwarding_parameter_node;
/** ForwardingSuperNode

 Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.

``` ruby
 super
 ^^^^^
```

``` ruby
 super { 123 }
 ^^^^^^^^^^^^^
```

 If it has any other arguments, it would be a `SuperNode` instead.

 Type: ::PM_FORWARDING_SUPER_NODE

 @extends pm_node_t
*/
pub type pm_forwarding_super_node_t = pm_forwarding_super_node;
/** GlobalVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a global variable.

``` ruby
 $target &&= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_and_write_node_t = pm_global_variable_and_write_node;
/** GlobalVariableOperatorWriteNode

 Represents assigning to a global variable using an operator that isn't `=`.

``` ruby
 $target += value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_operator_write_node_t = pm_global_variable_operator_write_node;
/** GlobalVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a global variable.

``` ruby
 $target ||= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_or_write_node_t = pm_global_variable_or_write_node;
/** GlobalVariableReadNode

 Represents referencing a global variable.

``` ruby
 $foo
 ^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_read_node_t = pm_global_variable_read_node;
/** GlobalVariableTargetNode

 Represents writing to a global variable in a context that doesn't have an explicit value.

``` ruby
 $foo, $bar = baz
 ^^^^  ^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_target_node_t = pm_global_variable_target_node;
/** GlobalVariableWriteNode

 Represents writing to a global variable.

``` ruby
 $foo = 1
 ^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_global_variable_write_node_t = pm_global_variable_write_node;
/** HashNode

 Represents a hash literal.

``` ruby
 { a => b }
 ^^^^^^^^^^
```

 Type: ::PM_HASH_NODE

 @extends pm_node_t
*/
pub type pm_hash_node_t = pm_hash_node;
/** HashPatternNode

 Represents a hash pattern in pattern matching.

``` ruby
 foo => { a: 1, b: 2 }
        ^^^^^^^^^^^^^^
```

``` ruby
 foo => { a: 1, b: 2, **c }
        ^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo => Bar[a: 1, b: 2]
        ^^^^^^^^^^^^^^^
```

``` ruby
 foo in { a: 1, b: 2 }
        ^^^^^^^^^^^^^^
```

 Type: ::PM_HASH_PATTERN_NODE

 @extends pm_node_t
*/
pub type pm_hash_pattern_node_t = pm_hash_pattern_node;
/** IfNode

 Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.

``` ruby
 bar if foo
 ^^^^^^^^^^
```

``` ruby
 if foo then bar end
 ^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo ? bar : baz
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_IF_NODE

 @extends pm_node_t
*/
pub type pm_if_node_t = pm_if_node;
/** ImaginaryNode

 Represents an imaginary number literal.

``` ruby
 1.0i
 ^^^^
```

 Type: ::PM_IMAGINARY_NODE

 @extends pm_node_t
*/
pub type pm_imaginary_node_t = pm_imaginary_node;
/** ImplicitNode

 Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.

``` ruby
 { foo: }
   ^^^^
```

``` ruby
 { Foo: }
   ^^^^
```

``` ruby
 foo in { bar: }
          ^^^^
```

 Type: ::PM_IMPLICIT_NODE

 @extends pm_node_t
*/
pub type pm_implicit_node_t = pm_implicit_node;
/** ImplicitRestNode

 Represents using a trailing comma to indicate an implicit rest parameter.

``` ruby
 foo { |bar,| }
           ^
```

``` ruby
 foo in [bar,]
            ^
```

``` ruby
 for foo, in bar do end
        ^
```

``` ruby
 foo, = bar
    ^
```

 Type: ::PM_IMPLICIT_REST_NODE

 @extends pm_node_t
*/
pub type pm_implicit_rest_node_t = pm_implicit_rest_node;
/** InNode

 Represents the use of the `in` keyword in a case statement.

``` ruby
 case a; in b then c end
         ^^^^^^^^^^^
```

 Type: ::PM_IN_NODE

 @extends pm_node_t
*/
pub type pm_in_node_t = pm_in_node;
/** IndexAndWriteNode

 Represents the use of the `&&=` operator on a call to the `[]` method.

``` ruby
 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
*/
pub type pm_index_and_write_node_t = pm_index_and_write_node;
/** IndexOperatorWriteNode

 Represents the use of an assignment operator on a call to `[]`.

``` ruby
 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
*/
pub type pm_index_operator_write_node_t = pm_index_operator_write_node;
/** IndexOrWriteNode

 Represents the use of the `||=` operator on a call to `[]`.

``` ruby
 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
*/
pub type pm_index_or_write_node_t = pm_index_or_write_node;
/** IndexTargetNode

 Represents assigning to an index.

``` ruby
 foo[bar], = 1
 ^^^^^^^^
```

``` ruby
 begin
 rescue => foo[bar]
           ^^^^^^^^
 end
```

``` ruby
 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
*/
pub type pm_index_target_node_t = pm_index_target_node;
/** InstanceVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to an instance variable.

``` ruby
 @target &&= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_and_write_node_t = pm_instance_variable_and_write_node;
/** InstanceVariableOperatorWriteNode

 Represents assigning to an instance variable using an operator that isn't `=`.

``` ruby
 @target += value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_operator_write_node_t = pm_instance_variable_operator_write_node;
/** InstanceVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to an instance variable.

``` ruby
 @target ||= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_or_write_node_t = pm_instance_variable_or_write_node;
/** InstanceVariableReadNode

 Represents referencing an instance variable.

``` ruby
 @foo
 ^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_READ_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_read_node_t = pm_instance_variable_read_node;
/** InstanceVariableTargetNode

 Represents writing to an instance variable in a context that doesn't have an explicit value.

``` ruby
 @foo, @bar = baz
 ^^^^  ^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_target_node_t = pm_instance_variable_target_node;
/** InstanceVariableWriteNode

 Represents writing to an instance variable.

``` ruby
 @foo = 1
 ^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_instance_variable_write_node_t = pm_instance_variable_write_node;
/** IntegerNode

 Represents an integer number literal.

``` ruby
 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
*/
pub type pm_integer_node_t = pm_integer_node;
/** 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.

``` ruby
 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
*/
pub type pm_interpolated_match_last_line_node_t = pm_interpolated_match_last_line_node;
/** InterpolatedRegularExpressionNode

 Represents a regular expression literal that contains interpolation.

``` ruby
 /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
*/
pub type pm_interpolated_regular_expression_node_t = pm_interpolated_regular_expression_node;
/** InterpolatedStringNode

 Represents a string literal that contains interpolation.

``` ruby
 "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
*/
pub type pm_interpolated_string_node_t = pm_interpolated_string_node;
/** InterpolatedSymbolNode

 Represents a symbol literal that contains interpolation.

``` ruby
 :"foo #{bar} baz"
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INTERPOLATED_SYMBOL_NODE

 @extends pm_node_t
*/
pub type pm_interpolated_symbol_node_t = pm_interpolated_symbol_node;
/** InterpolatedXStringNode

 Represents an xstring literal that contains interpolation.

``` ruby
 `foo #{bar} baz`
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_INTERPOLATED_X_STRING_NODE

 @extends pm_node_t
*/
pub type pm_interpolated_x_string_node_t = pm_interpolated_x_string_node;
/** ItLocalVariableReadNode

 Represents reading from the implicit `it` local variable.

``` ruby
 -> { it }
      ^^
```

 Type: ::PM_IT_LOCAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
pub type pm_it_local_variable_read_node_t = pm_it_local_variable_read_node;
/** ItParametersNode

 Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.

``` ruby
 -> { it + it }
 ^^^^^^^^^^^^^^
```

 Type: ::PM_IT_PARAMETERS_NODE

 @extends pm_node_t
*/
pub type pm_it_parameters_node_t = pm_it_parameters_node;
/** KeywordHashNode

 Represents a hash literal without opening and closing braces.

``` ruby
 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
*/
pub type pm_keyword_hash_node_t = pm_keyword_hash_node;
/** KeywordRestParameterNode

 Represents a keyword rest parameter to a method, block, or lambda definition.

``` ruby
 def a(**b)
       ^^^
 end
```

 Type: ::PM_KEYWORD_REST_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_keyword_rest_parameter_node_t = pm_keyword_rest_parameter_node;
/** LambdaNode

 Represents using a lambda literal (not the lambda method call).

``` ruby
 ->(value) { value * 2 }
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_LAMBDA_NODE

 @extends pm_node_t
*/
pub type pm_lambda_node_t = pm_lambda_node;
/** LocalVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a local variable.

``` ruby
 target &&= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_and_write_node_t = pm_local_variable_and_write_node;
/** LocalVariableOperatorWriteNode

 Represents assigning to a local variable using an operator that isn't `=`.

``` ruby
 target += value
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_operator_write_node_t = pm_local_variable_operator_write_node;
/** LocalVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a local variable.

``` ruby
 target ||= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_or_write_node_t = pm_local_variable_or_write_node;
/** 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.

``` ruby
 foo
 ^^^
```

 Type: ::PM_LOCAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_read_node_t = pm_local_variable_read_node;
/** LocalVariableTargetNode

 Represents writing to a local variable in a context that doesn't have an explicit value.

``` ruby
 foo, bar = baz
 ^^^  ^^^
```

``` ruby
 foo => baz
        ^^^
```

 Type: ::PM_LOCAL_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_target_node_t = pm_local_variable_target_node;
/** LocalVariableWriteNode

 Represents writing to a local variable.

``` ruby
 foo = 1
 ^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_local_variable_write_node_t = pm_local_variable_write_node;
/** 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.

``` ruby
 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
*/
pub type pm_match_last_line_node_t = pm_match_last_line_node;
/** MatchPredicateNode

 Represents the use of the modifier `in` operator.

``` ruby
 foo in bar
 ^^^^^^^^^^
```

 Type: ::PM_MATCH_PREDICATE_NODE

 @extends pm_node_t
*/
pub type pm_match_predicate_node_t = pm_match_predicate_node;
/** MatchRequiredNode

 Represents the use of the `=>` operator.

``` ruby
 foo => bar
 ^^^^^^^^^^
```

 Type: ::PM_MATCH_REQUIRED_NODE

 @extends pm_node_t
*/
pub type pm_match_required_node_t = pm_match_required_node;
/** MatchWriteNode

 Represents writing local variables using a regular expression match with named capture groups.

``` ruby
 /(?<foo>bar)/ =~ baz
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_MATCH_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_match_write_node_t = pm_match_write_node;
/** ModuleNode

 Represents a module declaration involving the `module` keyword.

``` ruby
 module Foo end
 ^^^^^^^^^^^^^^
```

 Type: ::PM_MODULE_NODE

 @extends pm_node_t
*/
pub type pm_module_node_t = pm_module_node;
/** MultiTargetNode

 Represents a multi-target expression.

``` ruby
 a, (b, c) = 1, 2, 3
    ^^^^^^
```

 This can be a part of `MultiWriteNode` as above, or the target of a `for` loop

``` ruby
 for a, b in [[1, 2], [3, 4]]
     ^^^^
```

 Type: ::PM_MULTI_TARGET_NODE

 @extends pm_node_t
*/
pub type pm_multi_target_node_t = pm_multi_target_node;
/** MultiWriteNode

 Represents a write to a multi-target expression.

``` ruby
 a, b, c = 1, 2, 3
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_MULTI_WRITE_NODE

 @extends pm_node_t
*/
pub type pm_multi_write_node_t = pm_multi_write_node;
/** NextNode

 Represents the use of the `next` keyword.

``` ruby
 next 1
 ^^^^^^
```

 Type: ::PM_NEXT_NODE

 @extends pm_node_t
*/
pub type pm_next_node_t = pm_next_node;
/** NilNode

 Represents the use of the `nil` keyword.

``` ruby
 nil
 ^^^
```

 Type: ::PM_NIL_NODE

 @extends pm_node_t
*/
pub type pm_nil_node_t = pm_nil_node;
/** NoBlockParameterNode

 Represents the use of `&nil` inside method arguments.

``` ruby
 def a(&nil)
       ^^^^
 end
```

 Type: ::PM_NO_BLOCK_PARAMETER_NODE

 @extends pm_node_t
*/
pub type pm_no_block_parameter_node_t = pm_no_block_parameter_node;
/** NoKeywordsParameterNode

 Represents the use of `**nil` inside method arguments.

``` ruby
 def a(**nil)
       ^^^^^
 end
```

 Type: ::PM_NO_KEYWORDS_PARAMETER_NODE

 @extends pm_node_t
*/
pub type pm_no_keywords_parameter_node_t = pm_no_keywords_parameter_node;
/** NumberedParametersNode

 Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.

``` ruby
 -> { _1 + _2 }
 ^^^^^^^^^^^^^^
```

 Type: ::PM_NUMBERED_PARAMETERS_NODE

 @extends pm_node_t
*/
pub type pm_numbered_parameters_node_t = pm_numbered_parameters_node;
/** NumberedReferenceReadNode

 Represents reading a numbered reference to a capture in the previous match.

``` ruby
 $1
 ^^
```

 Type: ::PM_NUMBERED_REFERENCE_READ_NODE

 @extends pm_node_t
*/
pub type pm_numbered_reference_read_node_t = pm_numbered_reference_read_node;
/** OptionalKeywordParameterNode

 Represents an optional keyword parameter to a method, block, or lambda definition.

``` ruby
 def a(b: 1)
       ^^^^
 end
```

 Type: ::PM_OPTIONAL_KEYWORD_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_optional_keyword_parameter_node_t = pm_optional_keyword_parameter_node;
/** OptionalParameterNode

 Represents an optional parameter to a method, block, or lambda definition.

``` ruby
 def a(b = 1)
       ^^^^^
 end
```

 Type: ::PM_OPTIONAL_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_optional_parameter_node_t = pm_optional_parameter_node;
/** OrNode

 Represents the use of the `||` operator or the `or` keyword.

``` ruby
 left or right
 ^^^^^^^^^^^^^
```

 Type: ::PM_OR_NODE

 @extends pm_node_t
*/
pub type pm_or_node_t = pm_or_node;
/** ParametersNode

 Represents the list of parameters on a method, block, or lambda definition.

``` ruby
 def a(b, c, d)
       ^^^^^^^
 end
```

 Type: ::PM_PARAMETERS_NODE

 @extends pm_node_t
*/
pub type pm_parameters_node_t = pm_parameters_node;
/** ParenthesesNode

 Represents a parenthesized expression

``` ruby
 (10 + 34)
 ^^^^^^^^^
```

 Type: ::PM_PARENTHESES_NODE

 Flags (#pm_parentheses_node_flags):
 * ::PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS

 @extends pm_node_t
*/
pub type pm_parentheses_node_t = pm_parentheses_node;
/** PinnedExpressionNode

 Represents the use of the `^` operator for pinning an expression in a pattern matching expression.

``` ruby
 foo in ^(bar)
        ^^^^^^
```

 Type: ::PM_PINNED_EXPRESSION_NODE

 @extends pm_node_t
*/
pub type pm_pinned_expression_node_t = pm_pinned_expression_node;
/** PinnedVariableNode

 Represents the use of the `^` operator for pinning a variable in a pattern matching expression.

``` ruby
 foo in ^bar
        ^^^^
```

 Type: ::PM_PINNED_VARIABLE_NODE

 @extends pm_node_t
*/
pub type pm_pinned_variable_node_t = pm_pinned_variable_node;
/** PostExecutionNode

 Represents the use of the `END` keyword.

``` ruby
 END { foo }
 ^^^^^^^^^^^
```

 Type: ::PM_POST_EXECUTION_NODE

 @extends pm_node_t
*/
pub type pm_post_execution_node_t = pm_post_execution_node;
/** PreExecutionNode

 Represents the use of the `BEGIN` keyword.

``` ruby
 BEGIN { foo }
 ^^^^^^^^^^^^^
```

 Type: ::PM_PRE_EXECUTION_NODE

 @extends pm_node_t
*/
pub type pm_pre_execution_node_t = pm_pre_execution_node;
/** ProgramNode

 The top level node of any parse tree.

 Type: ::PM_PROGRAM_NODE

 @extends pm_node_t
*/
pub type pm_program_node_t = pm_program_node;
/** RangeNode

 Represents the use of the `..` or `...` operators.

``` ruby
 1..2
 ^^^^
```

``` ruby
 c if a =~ /left/ ... b =~ /right/
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_RANGE_NODE

 Flags (#pm_range_flags):
 * ::PM_RANGE_FLAGS_EXCLUDE_END

 @extends pm_node_t
*/
pub type pm_range_node_t = pm_range_node;
/** RationalNode

 Represents a rational number literal.

``` ruby
 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
*/
pub type pm_rational_node_t = pm_rational_node;
/** RedoNode

 Represents the use of the `redo` keyword.

``` ruby
 redo
 ^^^^
```

 Type: ::PM_REDO_NODE

 @extends pm_node_t
*/
pub type pm_redo_node_t = pm_redo_node;
/** RegularExpressionNode

 Represents a regular expression literal with no interpolation.

``` ruby
 /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
*/
pub type pm_regular_expression_node_t = pm_regular_expression_node;
/** RequiredKeywordParameterNode

 Represents a required keyword parameter to a method, block, or lambda definition.

``` ruby
 def a(b: )
       ^^
 end
```

 Type: ::PM_REQUIRED_KEYWORD_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_required_keyword_parameter_node_t = pm_required_keyword_parameter_node;
/** RequiredParameterNode

 Represents a required parameter to a method, block, or lambda definition.

``` ruby
 def a(b)
       ^
 end
```

 Type: ::PM_REQUIRED_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_required_parameter_node_t = pm_required_parameter_node;
/** RescueModifierNode

 Represents an expression modified with a rescue.

``` ruby
 foo rescue nil
 ^^^^^^^^^^^^^^
```

 Type: ::PM_RESCUE_MODIFIER_NODE

 @extends pm_node_t
*/
pub type pm_rescue_modifier_node_t = pm_rescue_modifier_node;
/** RescueNode

 Represents a rescue statement.

``` ruby
 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
*/
pub type pm_rescue_node_t = pm_rescue_node;
/** RestParameterNode

 Represents a rest parameter to a method, block, or lambda definition.

``` ruby
 def a(*b)
       ^^
 end
```

 Type: ::PM_REST_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
pub type pm_rest_parameter_node_t = pm_rest_parameter_node;
/** RetryNode

 Represents the use of the `retry` keyword.

``` ruby
 retry
 ^^^^^
```

 Type: ::PM_RETRY_NODE

 @extends pm_node_t
*/
pub type pm_retry_node_t = pm_retry_node;
/** ReturnNode

 Represents the use of the `return` keyword.

``` ruby
 return 1
 ^^^^^^^^
```

 Type: ::PM_RETURN_NODE

 @extends pm_node_t
*/
pub type pm_return_node_t = pm_return_node;
/** SelfNode

 Represents the `self` keyword.

``` ruby
 self
 ^^^^
```

 Type: ::PM_SELF_NODE

 @extends pm_node_t
*/
pub type pm_self_node_t = pm_self_node;
/** ShareableConstantNode

 This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.

``` ruby
 # 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
*/
pub type pm_shareable_constant_node_t = pm_shareable_constant_node;
/** SingletonClassNode

 Represents a singleton class declaration involving the `class` keyword.

``` ruby
 class << self end
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_SINGLETON_CLASS_NODE

 @extends pm_node_t
*/
pub type pm_singleton_class_node_t = pm_singleton_class_node;
/** SourceEncodingNode

 Represents the use of the `__ENCODING__` keyword.

``` ruby
 __ENCODING__
 ^^^^^^^^^^^^
```

 Type: ::PM_SOURCE_ENCODING_NODE

 @extends pm_node_t
*/
pub type pm_source_encoding_node_t = pm_source_encoding_node;
/** SourceFileNode

 Represents the use of the `__FILE__` keyword.

``` ruby
 __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
*/
pub type pm_source_file_node_t = pm_source_file_node;
/** SourceLineNode

 Represents the use of the `__LINE__` keyword.

``` ruby
 __LINE__
 ^^^^^^^^
```

 Type: ::PM_SOURCE_LINE_NODE

 @extends pm_node_t
*/
pub type pm_source_line_node_t = pm_source_line_node;
/** SplatNode

 Represents the use of the splat operator.

``` ruby
 [*a]
  ^^
```

 Type: ::PM_SPLAT_NODE

 @extends pm_node_t
*/
pub type pm_splat_node_t = pm_splat_node;
/** StatementsNode

 Represents a set of statements contained within some scope.

``` ruby
 foo; bar; baz
 ^^^^^^^^^^^^^
```

 Type: ::PM_STATEMENTS_NODE

 @extends pm_node_t
*/
pub type pm_statements_node_t = pm_statements_node;
/** StringNode

 Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.

``` ruby
 "foo"
 ^^^^^
```

``` ruby
 %w[foo]
    ^^^
```

``` ruby
 "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
*/
pub type pm_string_node_t = pm_string_node;
/** SuperNode

 Represents the use of the `super` keyword with parentheses or arguments.

``` ruby
 super()
 ^^^^^^^
```

``` ruby
 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
*/
pub type pm_super_node_t = pm_super_node;
/** SymbolNode

 Represents a symbol literal or a symbol contained within a `%i` list.

``` ruby
 :foo
 ^^^^
```

``` ruby
 %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
*/
pub type pm_symbol_node_t = pm_symbol_node;
/** TrueNode

 Represents the use of the literal `true` keyword.

``` ruby
 true
 ^^^^
```

 Type: ::PM_TRUE_NODE

 @extends pm_node_t
*/
pub type pm_true_node_t = pm_true_node;
/** UndefNode

 Represents the use of the `undef` keyword.

``` ruby
 undef :foo, :bar, :baz
 ^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNDEF_NODE

 @extends pm_node_t
*/
pub type pm_undef_node_t = pm_undef_node;
/** UnlessNode

 Represents the use of the `unless` keyword, either in the block form or the modifier form.

``` ruby
 bar unless foo
 ^^^^^^^^^^^^^^
```

``` ruby
 unless foo then bar end
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNLESS_NODE

 @extends pm_node_t
*/
pub type pm_unless_node_t = pm_unless_node;
/** UntilNode

 Represents the use of the `until` keyword, either in the block form or the modifier form.

``` ruby
 bar until foo
 ^^^^^^^^^^^^^
```

``` ruby
 until foo do bar end
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNTIL_NODE

 Flags (#pm_loop_flags):
 * ::PM_LOOP_FLAGS_BEGIN_MODIFIER

 @extends pm_node_t
*/
pub type pm_until_node_t = pm_until_node;
/** WhenNode

 Represents the use of the `when` keyword within a case statement.

``` ruby
 case true
 when true
 ^^^^^^^^^
 end
```

 Type: ::PM_WHEN_NODE

 @extends pm_node_t
*/
pub type pm_when_node_t = pm_when_node;
/** WhileNode

 Represents the use of the `while` keyword, either in the block form or the modifier form.

``` ruby
 bar while foo
 ^^^^^^^^^^^^^
```

``` ruby
 while foo do bar end
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_WHILE_NODE

 Flags (#pm_loop_flags):
 * ::PM_LOOP_FLAGS_BEGIN_MODIFIER

 @extends pm_node_t
*/
pub type pm_while_node_t = pm_while_node;
/** XStringNode

 Represents an xstring literal with no interpolation.

``` ruby
 `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
*/
pub type pm_x_string_node_t = pm_x_string_node;
/** YieldNode

 Represents the use of the `yield` keyword.

``` ruby
 yield 1
 ^^^^^^^
```

 Type: ::PM_YIELD_NODE

 @extends pm_node_t
*/
pub type pm_yield_node_t = pm_yield_node;
/** Represents the results of a slice query.
*/
pub type pm_string_query_t = ::std::os::raw::c_int;
/** An opaque pointer to an arena that is used for allocations.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_arena_t {
    _unused: [u8; 0],
}
/** A list of constant IDs. Usually used to represent a set of locals.
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_id_list_t {
    /** The number of constant ids in the list.
*/
    pub size: usize,
    /** The number of constant ids that have been allocated in the list.
*/
    pub capacity: usize,
    /** The constant ids in the list.
*/
    pub ids: *mut pm_constant_id_t,
}
/** A constant in the pool which effectively stores a string.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_constant_t {
    _unused: [u8; 0],
}
/** A structure represents an arbitrary-sized integer.
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_integer_t {
    /** The number of allocated values. length is set to 0 if the integer fits
 into uint32_t.
*/
    pub length: usize,
    /** List of 32-bit integers. Set to NULL if the integer fits into uint32_t.
*/
    pub values: *mut u32,
    /** Embedded value for small integer. This value is set to 0 if the value
 does not fit into uint32_t.
*/
    pub value: u32,
    /** Whether or not the integer is negative. It is stored this way so that a
 zeroed pm_integer_t is always positive zero.
*/
    pub negative: bool,
}
/** A view of a sequence of bytes. The string does not own the bytes, so they
 must remain valid for as long as the string is in use.
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_string_t {
    /** A pointer to the start of the string.
*/
    pub source: *const u8,
    /** The length of the string in bytes of memory.
*/
    pub length: usize,
}
/** This struct represents a slice in the source code, defined by an offset and
 a length. Note that we have confirmation that we can represent all locations
 within Ruby source files using 32-bit integers per:

``` ruby
 https://bugs.ruby-lang.org/issues/20488#note-1
```
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_location_t {
    /** The offset of the location from the start of the source.
*/
    pub start: u32,
    /** The length of the location.
*/
    pub length: u32,
}
/** A list of nodes in the source, most often used for lists of children.
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_node_list {
    /** The number of nodes in the list.
*/
    pub size: usize,
    /** The capacity of the list that has been allocated.
*/
    pub capacity: usize,
    /** The nodes in the list.
*/
    pub nodes: *mut *mut pm_node,
}
/** This is the base structure that represents a node in the syntax tree. It is
 embedded into every node type.
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub 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 is not a 1:1 mapping.
*/
    pub type_: pm_node_type_t,
    /** This represents any flags on the node. Some are common to all nodes, and
 some are specific to the type of node.
*/
    pub flags: pm_node_flags_t,
    /** The unique identifier for this node, which is deterministic based on the
 source. It is used to identify unique nodes across parses. Nodes created
 outside of parsing have no position in the source and can use 0, which
 no parsed node uses.
*/
    pub node_id: u32,
    /** This is the location of the node in the source. It is a range of bytes
 containing a start and an end.
*/
    pub location: pm_location_t,
}
/** AliasGlobalVariableNode

 Represents the use of the `alias` keyword to alias a global variable.

``` ruby
 alias $foo $bar
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_ALIAS_GLOBAL_VARIABLE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_alias_global_variable_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** AliasGlobalVariableNode#new_name

 Represents the new name of the global variable that can be used after aliasing.

``` ruby
 alias $foo $bar
       ^^^^
```
*/
    pub new_name: *mut pm_node,
    /** AliasGlobalVariableNode#old_name

 Represents the old name of the global variable that can be used before aliasing.

``` ruby
 alias $foo $bar
            ^^^^
```
*/
    pub old_name: *mut pm_node,
    /** AliasGlobalVariableNode#keyword_loc

 The Location of the `alias` keyword.

``` ruby
 alias $foo $bar
 ^^^^^
```
*/
    pub keyword_loc: pm_location_t,
}
/** AliasMethodNode

 Represents the use of the `alias` keyword to alias a method.

``` ruby
 alias foo bar
 ^^^^^^^^^^^^^
```

 Type: ::PM_ALIAS_METHOD_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_alias_method_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** AliasMethodNode#new_name

 Represents the new name of the method that will be aliased.

``` ruby
 alias foo bar
       ^^^
```

``` ruby
 alias :foo :bar
       ^^^^
```

``` ruby
 alias :"#{foo}" :"#{bar}"
       ^^^^^^^^^
```
*/
    pub new_name: *mut pm_node,
    /** AliasMethodNode#old_name

 Represents the old name of the method that will be aliased.

``` ruby
 alias foo bar
           ^^^
```

``` ruby
 alias :foo :bar
            ^^^^
```

``` ruby
 alias :"#{foo}" :"#{bar}"
                 ^^^^^^^^^
```
*/
    pub old_name: *mut pm_node,
    /** AliasMethodNode#keyword_loc

 Represents the Location of the `alias` keyword.

``` ruby
 alias foo bar
 ^^^^^
```
*/
    pub keyword_loc: pm_location_t,
}
/** AlternationPatternNode

 Represents an alternation pattern in pattern matching.

``` ruby
 foo => bar | baz
        ^^^^^^^^^
```

 Type: ::PM_ALTERNATION_PATTERN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_alternation_pattern_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** AlternationPatternNode#left

 Represents the left side of the expression.

``` ruby
 foo => bar | baz
        ^^^
```
*/
    pub left: *mut pm_node,
    /** AlternationPatternNode#right

 Represents the right side of the expression.

``` ruby
 foo => bar | baz
              ^^^
```
*/
    pub right: *mut pm_node,
    /** AlternationPatternNode#operator_loc

 Represents the alternation operator Location.

``` ruby
 foo => bar | baz
            ^
```
*/
    pub operator_loc: pm_location_t,
}
/** AndNode

 Represents the use of the `&&` operator or the `and` keyword.

``` ruby
 left and right
 ^^^^^^^^^^^^^^
```

 Type: ::PM_AND_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_and_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 left and right
 ^^^^
```

``` ruby
 1 && 2
 ^
```
*/
    pub left: *mut pm_node,
    /** AndNode#right

 Represents the right side of the expression.

``` ruby
 left && right
         ^^^^^
```

``` ruby
 1 and 2
       ^
```
*/
    pub right: *mut pm_node,
    /** AndNode#operator_loc

 The Location of the `and` keyword or the `&&` operator.

``` ruby
 left and right
      ^^^
```
*/
    pub operator_loc: pm_location_t,
}
/** ArgumentsNode

 Represents a set of arguments to a method or a keyword.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_arguments_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo(bar, baz)
     ^^^^^^^^
```
*/
    pub arguments: pm_node_list,
}
/** ArrayNode

 Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.

``` ruby
 [1, 2, 3]
 ^^^^^^^^^
```

 Type: ::PM_ARRAY_NODE

 Flags (#pm_array_node_flags):
 * ::PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_array_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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.
*/
    pub elements: pm_node_list,
    /** ArrayNode#opening_loc

 Represents the optional source Location for the opening token.

``` ruby
 [1,2,3]                 # "["
 %w[foo bar baz]         # "%w["
 %I(apple orange banana) # "%I("
 foo = 1, 2, 3           # nil
```
*/
    pub opening_loc: pm_location_t,
    /** ArrayNode#closing_loc

 Represents the optional source Location for the closing token.

``` ruby
 [1,2,3]                 # "]"
 %w[foo bar baz]         # "]"
 %I(apple orange banana) # ")"
 foo = 1, 2, 3           # nil
```
*/
    pub closing_loc: pm_location_t,
}
/** ArrayPatternNode

 Represents an array pattern in pattern matching.

``` ruby
 foo in 1, 2
        ^^^^
```

``` ruby
 foo in [1, 2]
        ^^^^^^
```

``` ruby
 foo in *bar
        ^^^^
```

``` ruby
 foo in Bar[]
        ^^^^^
```

``` ruby
 foo in Bar[1, 2, 3]
        ^^^^^^^^^^^^
```

 Type: ::PM_ARRAY_PATTERN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_array_pattern_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ArrayPatternNode#constant

 Represents the optional constant preceding the Array

``` ruby
 foo in Bar[]
        ^^^
```

``` ruby
 foo in Bar[1, 2, 3]
        ^^^
```

``` ruby
 foo in Bar::Baz[1, 2, 3]
        ^^^^^^^^
```
*/
    pub constant: *mut pm_node,
    /** ArrayPatternNode#requireds

 Represents the required elements of the array pattern.

``` ruby
 foo in [1, 2]
         ^  ^
```
*/
    pub requireds: pm_node_list,
    /** ArrayPatternNode#rest

 Represents the rest element of the array pattern.

``` ruby
 foo in *bar
        ^^^^
```
*/
    pub rest: *mut pm_node,
    /** ArrayPatternNode#posts

 Represents the elements after the rest element of the array pattern.

``` ruby
 foo in *bar, baz
              ^^^
```
*/
    pub posts: pm_node_list,
    /** ArrayPatternNode#opening_loc

 Represents the opening Location of the array pattern.

``` ruby
 foo in [1, 2]
        ^
```
*/
    pub opening_loc: pm_location_t,
    /** ArrayPatternNode#closing_loc

 Represents the closing Location of the array pattern.

``` ruby
 foo in [1, 2]
             ^
```
*/
    pub closing_loc: pm_location_t,
}
/** AssocNode

 Represents a hash key/value pair.

``` ruby
 { a => b }
   ^^^^^^
```

 Type: ::PM_ASSOC_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_assoc_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 { a: b }
   ^
```

``` ruby
 { foo => bar }
   ^^^
```

``` ruby
 { def a; end => 1 }
   ^^^^^^^^^^
```
*/
    pub key: *mut pm_node,
    /** 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).

``` ruby
 { foo => bar }
          ^^^
```

``` ruby
 { x: 1 }
      ^
```
*/
    pub value: *mut pm_node,
    /** AssocNode#operator_loc

 The Location of the `=>` operator, if present.

``` ruby
 { foo => bar }
       ^^
```
*/
    pub operator_loc: pm_location_t,
}
/** AssocSplatNode

 Represents a splat in a hash literal.

``` ruby
 { **foo }
   ^^^^^
```

 Type: ::PM_ASSOC_SPLAT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_assoc_splat_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** AssocSplatNode#value

 The value to be splatted, if present. Will be missing when keyword rest argument forwarding is used.

``` ruby
 { **foo }
     ^^^
```
*/
    pub value: *mut pm_node,
    /** AssocSplatNode#operator_loc

 The Location of the `**` operator.

``` ruby
 { **x }
   ^^
```
*/
    pub operator_loc: pm_location_t,
}
/** BackReferenceReadNode

 Represents reading a reference to a field in the previous match.

``` ruby
 $'
 ^^
```

 Type: ::PM_BACK_REFERENCE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_back_reference_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BackReferenceReadNode#name

 The name of the back-reference variable, including the leading `$`.

``` ruby
 $& # name `:$&`
```

``` ruby
 $+ # name `:$+`
```
*/
    pub name: pm_constant_id_t,
}
/** BeginNode

 Represents a begin statement.

``` ruby
 begin
   foo
 end
 ^^^^^
```

 Type: ::PM_BEGIN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_begin_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BeginNode#begin_keyword_loc

 Represents the Location of the `begin` keyword.

``` ruby
 begin x end
 ^^^^^
```
*/
    pub begin_keyword_loc: pm_location_t,
    /** BeginNode#statements

 Represents the statements within the begin block.

``` ruby
 begin x end
       ^
```
*/
    pub statements: *mut pm_statements_node,
    /** BeginNode#rescue_clause

 Represents the rescue clause within the begin block.

``` ruby
 begin x; rescue y; end
          ^^^^^^^^
```
*/
    pub rescue_clause: *mut pm_rescue_node,
    /** BeginNode#else_clause

 Represents the else clause within the begin block.

``` ruby
 begin x; rescue y; else z; end
                    ^^^^^^^^^^^
```
*/
    pub else_clause: *mut pm_else_node,
    /** BeginNode#ensure_clause

 Represents the ensure clause within the begin block.

``` ruby
 begin x; ensure y; end
          ^^^^^^^^
```
*/
    pub ensure_clause: *mut pm_ensure_node,
    /** BeginNode#end_keyword_loc

 Represents the Location of the `end` keyword.

``` ruby
 begin x end
         ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** BlockArgumentNode

 Represents a block argument using `&`.

``` ruby
 bar(&args)
     ^^^^^
```

 Type: ::PM_BLOCK_ARGUMENT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_block_argument_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo(&args)
      ^^^^
```
*/
    pub expression: *mut pm_node,
    /** BlockArgumentNode#operator_loc

 Represents the Location of the `&` operator.

``` ruby
 foo(&args)
     ^
```
*/
    pub operator_loc: pm_location_t,
}
/** BlockLocalVariableNode

 Represents a block local variable.

``` ruby
 a { |; b| }
        ^
```

 Type: ::PM_BLOCK_LOCAL_VARIABLE_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_block_local_variable_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BlockLocalVariableNode#name

 The name of the block local variable.

``` ruby
 a { |; b| } # name `:b`
        ^
```
*/
    pub name: pm_constant_id_t,
}
/** BlockNode

 Represents a block of ruby code.

``` ruby
 [1, 2, 3].each { |i| puts x }
                ^^^^^^^^^^^^^^
```

 Type: ::PM_BLOCK_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_block_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BlockNode#locals

 The local variables declared in the block.

``` ruby
 [1, 2, 3].each { |i| puts x } # locals: [:i]
                   ^
```
*/
    pub locals: pm_constant_id_list_t,
    /** BlockNode#parameters

 The parameters of the block.

``` ruby
 [1, 2, 3].each { |i| puts x }
                  ^^^
 [1, 2, 3].each { puts _1 }
                ^^^^^^^^^^^
 [1, 2, 3].each { puts it }
                ^^^^^^^^^^^
```
*/
    pub parameters: *mut pm_node,
    /** BlockNode#body

 The body of the block.

``` ruby
 [1, 2, 3].each { |i| puts x }
                      ^^^^^^
```
*/
    pub body: *mut pm_node,
    /** BlockNode#opening_loc

 Represents the Location of the opening `{` or `do`.

``` ruby
 [1, 2, 3].each { |i| puts x }
                ^
```
*/
    pub opening_loc: pm_location_t,
    /** BlockNode#closing_loc

 Represents the Location of the closing `}` or `end`.

``` ruby
 [1, 2, 3].each { |i| puts x }
                             ^
```
*/
    pub closing_loc: pm_location_t,
}
/** BlockParameterNode

 Represents a block parameter of a method, block, or lambda definition.

``` ruby
 def a(&b)
       ^^
 end
```

 Type: ::PM_BLOCK_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_block_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BlockParameterNode#name

 The name of the block parameter.

``` ruby
 def a(&b) # name `:b`
        ^
 end
```
*/
    pub name: pm_constant_id_t,
    /** BlockParameterNode#name_loc

 Represents the Location of the block parameter name.

``` ruby
 def a(&b)
        ^
```
*/
    pub name_loc: pm_location_t,
    /** BlockParameterNode#operator_loc

 Represents the Location of the `&` operator.

``` ruby
 def a(&b)
       ^
 end
```
*/
    pub operator_loc: pm_location_t,
}
/** BlockParametersNode

 Represents a block's parameters declaration.

``` ruby
 -> (a, b = 1; local) { }
    ^^^^^^^^^^^^^^^^^
```

``` ruby
 foo do |a, b = 1; local|
        ^^^^^^^^^^^^^^^^^
 end
```

 Type: ::PM_BLOCK_PARAMETERS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_block_parameters_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** BlockParametersNode#parameters

 Represents the parameters of the block.

``` ruby
 -> (a, b = 1; local) { }
     ^^^^^^^^
```

``` ruby
 foo do |a, b = 1; local|
         ^^^^^^^^
 end
```
*/
    pub parameters: *mut pm_parameters_node,
    /** BlockParametersNode#locals

 Represents the local variables of the block.

``` ruby
 -> (a, b = 1; local) { }
               ^^^^^
```

``` ruby
 foo do |a, b = 1; local|
                   ^^^^^
 end
```
*/
    pub locals: pm_node_list,
    /** BlockParametersNode#opening_loc

 Represents the opening Location of the block parameters.

``` ruby
 -> (a, b = 1; local) { }
    ^
```

``` ruby
 foo do |a, b = 1; local|
        ^
 end
```
*/
    pub opening_loc: pm_location_t,
    /** BlockParametersNode#closing_loc

 Represents the closing Location of the block parameters.

``` ruby
 -> (a, b = 1; local) { }
                    ^
```

``` ruby
 foo do |a, b = 1; local|
                        ^
 end
```
*/
    pub closing_loc: pm_location_t,
}
/** BreakNode

 Represents the use of the `break` keyword.

``` ruby
 break foo
 ^^^^^^^^^
```

 Type: ::PM_BREAK_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_break_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 break foo
       ^^^
```
*/
    pub arguments: *mut pm_arguments_node,
    /** BreakNode#keyword_loc

 The Location of the `break` keyword.

``` ruby
 break foo
 ^^^^^
```
*/
    pub keyword_loc: pm_location_t,
}
/** CallAndWriteNode

 Represents the use of the `&&=` operator on a call.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_call_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo.bar &&= value
 ^^^
```
*/
    pub receiver: *mut pm_node,
    /** CallAndWriteNode#call_operator_loc

 Represents the Location of the call operator.

``` ruby
 foo.bar &&= value
    ^
```
*/
    pub call_operator_loc: pm_location_t,
    /** CallAndWriteNode#message_loc

 Represents the Location of the message.

``` ruby
 foo.bar &&= value
     ^^^
```
*/
    pub message_loc: pm_location_t,
    /** CallAndWriteNode#read_name

 Represents the name of the method being called.

``` ruby
 foo.bar &&= value # read_name `:bar`
     ^^^
```
*/
    pub read_name: pm_constant_id_t,
    /** CallAndWriteNode#write_name

 Represents the name of the method being written to.

``` ruby
 foo.bar &&= value # write_name `:bar=`
     ^^^
```
*/
    pub write_name: pm_constant_id_t,
    /** CallAndWriteNode#operator_loc

 Represents the Location of the operator.

``` ruby
 foo.bar &&= value
         ^^^
```
*/
    pub operator_loc: pm_location_t,
    /** CallAndWriteNode#value

 Represents the value being assigned.

``` ruby
 foo.bar &&= value
             ^^^^^
```
*/
    pub value: *mut pm_node,
}
/** CallNode

 Represents a method call, in all of the various forms that can take.

``` ruby
 foo
 ^^^
```

``` ruby
 foo()
 ^^^^^
```

``` ruby
 +foo
 ^^^^
```

``` ruby
 foo + bar
 ^^^^^^^^^
```

``` ruby
 foo.bar
 ^^^^^^^
```

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_call_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo.bar
 ^^^
```

``` ruby
 +foo
  ^^^
```

``` ruby
 foo + bar
 ^^^
```
*/
    pub receiver: *mut pm_node,
    /** CallNode#call_operator_loc

 Represents the Location of the call operator.

``` ruby
 foo.bar
    ^
```

``` ruby
 foo&.bar
    ^^
```
*/
    pub call_operator_loc: pm_location_t,
    /** CallNode#name

 Represents the name of the method being called.

``` ruby
 foo.bar # name `:foo`
 ^^^
```
*/
    pub name: pm_constant_id_t,
    /** CallNode#message_loc

 Represents the Location of the message.

``` ruby
 foo.bar
     ^^^
```
*/
    pub message_loc: pm_location_t,
    /** CallNode#opening_loc

 Represents the Location of the left parenthesis.

``` ruby
 foo(bar)
    ^
```
*/
    pub opening_loc: pm_location_t,
    /** 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).

``` ruby
 foo(bar)
     ^^^
```
*/
    pub arguments: *mut pm_arguments_node,
    /** CallNode#closing_loc

 Represents the Location of the right parenthesis.

``` ruby
 foo(bar)
        ^
```
*/
    pub closing_loc: pm_location_t,
    /** CallNode#equal_loc

 Represents the Location of the equal sign, in the case that this is an attribute write.

``` ruby
 foo.bar = value
         ^
```

``` ruby
 foo[bar] = value
          ^
```
*/
    pub equal_loc: pm_location_t,
    /** CallNode#block

 Represents the block that is being passed to the method.

``` ruby
 foo { |a| a }
     ^^^^^^^^^
```
*/
    pub block: *mut pm_node,
}
/** CallOperatorWriteNode

 Represents the use of an assignment operator on a call.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_call_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo.bar += value
 ^^^
```
*/
    pub receiver: *mut pm_node,
    /** CallOperatorWriteNode#call_operator_loc

 Represents the Location of the call operator.

``` ruby
 foo.bar += value
    ^
```
*/
    pub call_operator_loc: pm_location_t,
    /** CallOperatorWriteNode#message_loc

 Represents the Location of the message.

``` ruby
 foo.bar += value
     ^^^
```
*/
    pub message_loc: pm_location_t,
    /** CallOperatorWriteNode#read_name

 Represents the name of the method being called.

``` ruby
 foo.bar += value # read_name `:bar`
     ^^^
```
*/
    pub read_name: pm_constant_id_t,
    /** CallOperatorWriteNode#write_name

 Represents the name of the method being written to.

``` ruby
 foo.bar += value # write_name `:bar=`
     ^^^
```
*/
    pub write_name: pm_constant_id_t,
    /** CallOperatorWriteNode#binary_operator

 Represents the binary operator being used.

``` ruby
 foo.bar += value # binary_operator `:+`
         ^
```
*/
    pub binary_operator: pm_constant_id_t,
    /** CallOperatorWriteNode#binary_operator_loc

 Represents the Location of the binary operator.

``` ruby
 foo.bar += value
         ^^
```
*/
    pub binary_operator_loc: pm_location_t,
    /** CallOperatorWriteNode#value

 Represents the value being assigned.

``` ruby
 foo.bar += value
            ^^^^^
```
*/
    pub value: *mut pm_node,
}
/** CallOrWriteNode

 Represents the use of the `||=` operator on a call.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_call_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo.bar ||= value
 ^^^
```
*/
    pub receiver: *mut pm_node,
    /** CallOrWriteNode#call_operator_loc

 Represents the Location of the call operator.

``` ruby
 foo.bar ||= value
    ^
```
*/
    pub call_operator_loc: pm_location_t,
    /** CallOrWriteNode#message_loc

 Represents the Location of the message.

``` ruby
 foo.bar ||= value
     ^^^
```
*/
    pub message_loc: pm_location_t,
    /** CallOrWriteNode#read_name

 Represents the name of the method being called.

``` ruby
 foo.bar ||= value # read_name `:bar`
     ^^^
```
*/
    pub read_name: pm_constant_id_t,
    /** CallOrWriteNode#write_name

 Represents the name of the method being written to.

``` ruby
 foo.bar ||= value # write_name `:bar=`
     ^^^
```
*/
    pub write_name: pm_constant_id_t,
    /** CallOrWriteNode#operator_loc

 Represents the Location of the operator.

``` ruby
 foo.bar ||= value
         ^^^
```
*/
    pub operator_loc: pm_location_t,
    /** CallOrWriteNode#value

 Represents the value being assigned.

``` ruby
 foo.bar ||= value
             ^^^^^
```
*/
    pub value: *mut pm_node,
}
/** CallTargetNode

 Represents assigning to a method call.

``` ruby
 foo.bar, = 1
 ^^^^^^^
```

``` ruby
 begin
 rescue => foo.bar
           ^^^^^^^
 end
```

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_call_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 foo.bar = 1
 ^^^
```
*/
    pub receiver: *mut pm_node,
    /** CallTargetNode#call_operator_loc

 Represents the Location of the call operator.

``` ruby
 foo.bar = 1
    ^
```
*/
    pub call_operator_loc: pm_location_t,
    /** CallTargetNode#name

 Represents the name of the method being called.

``` ruby
 foo.bar = 1 # name `:foo`
 ^^^
```
*/
    pub name: pm_constant_id_t,
    /** CallTargetNode#message_loc

 Represents the Location of the message.

``` ruby
 foo.bar = 1
     ^^^
```
*/
    pub message_loc: pm_location_t,
}
/** CapturePatternNode

 Represents assigning to a local variable in pattern matching.

``` ruby
 foo => [bar => baz]
         ^^^^^^^^^^
```

 Type: ::PM_CAPTURE_PATTERN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_capture_pattern_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** CapturePatternNode#value

 Represents the value to capture.

``` ruby
 foo => bar
        ^^^
```
*/
    pub value: *mut pm_node,
    /** CapturePatternNode#target

 Represents the target of the capture.

``` ruby
 foo => bar
 ^^^
```
*/
    pub target: *mut pm_local_variable_target_node,
    /** CapturePatternNode#operator_loc

 Represents the Location of the `=>` operator.

``` ruby
 foo => bar
     ^^
```
*/
    pub operator_loc: pm_location_t,
}
/** CaseMatchNode

 Represents the use of a case statement for pattern matching.

``` ruby
 case true
 in false
 end
 ^^^^^^^^^
```

 Type: ::PM_CASE_MATCH_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_case_match_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 case true; in false; end
      ^^^^
```
*/
    pub predicate: *mut pm_node,
    /** CaseMatchNode#conditions

 Represents the conditions of the case match.

``` ruby
 case true; in false; end
            ^^^^^^^^
```
*/
    pub conditions: pm_node_list,
    /** CaseMatchNode#else_clause

 Represents the else clause of the case match.

``` ruby
 case true; in false; else; end
                      ^^^^^^^^^
```
*/
    pub else_clause: *mut pm_else_node,
    /** CaseMatchNode#case_keyword_loc

 Represents the Location of the `case` keyword.

``` ruby
 case true; in false; end
 ^^^^
```
*/
    pub case_keyword_loc: pm_location_t,
    /** CaseMatchNode#end_keyword_loc

 Represents the Location of the `end` keyword.

``` ruby
 case true; in false; end
                      ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** CaseNode

 Represents the use of a case statement.

``` ruby
 case true
 when false
 end
 ^^^^^^^^^^
```

 Type: ::PM_CASE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_case_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 case true; when false; end
      ^^^^
```
*/
    pub predicate: *mut pm_node,
    /** CaseNode#conditions

 Represents the conditions of the case statement.

``` ruby
 case true; when false; end
            ^^^^^^^^^^
```
*/
    pub conditions: pm_node_list,
    /** CaseNode#else_clause

 Represents the else clause of the case statement.

``` ruby
 case true; when false; else; end
                        ^^^^^^^^^
```
*/
    pub else_clause: *mut pm_else_node,
    /** CaseNode#case_keyword_loc

 Represents the Location of the `case` keyword.

``` ruby
 case true; when false; end
 ^^^^
```
*/
    pub case_keyword_loc: pm_location_t,
    /** CaseNode#end_keyword_loc

 Represents the Location of the `end` keyword.

``` ruby
 case true; when false; end
                        ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** ClassNode

 Represents a class declaration involving the `class` keyword.

``` ruby
 class Foo end
 ^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_class_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ClassNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** ClassNode#class_keyword_loc

 Represents the Location of the `class` keyword.

``` ruby
 class Foo end
 ^^^^^
```
*/
    pub class_keyword_loc: pm_location_t,
    /** ClassNode#constant_path
*/
    pub constant_path: *mut pm_node,
    /** ClassNode#inheritance_operator_loc

 Represents the Location of the `<` operator.

``` ruby
 class Foo < Bar
           ^
```
*/
    pub inheritance_operator_loc: pm_location_t,
    /** ClassNode#superclass

 Represents the superclass of the class.

``` ruby
 class Foo < Bar
             ^^^
```
*/
    pub superclass: *mut pm_node,
    /** ClassNode#body

 Represents the body of the class.

``` ruby
 class Foo; bar; end
            ^^^
```
*/
    pub body: *mut pm_node,
    /** ClassNode#end_keyword_loc

 Represents the Location of the `end` keyword.

``` ruby
 class Foo end
           ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
    /** ClassNode#name

 The name of the class.

``` ruby
 class Foo end # name `:Foo`
```
*/
    pub name: pm_constant_id_t,
}
/** ClassVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a class variable.

``` ruby
 @@target &&= value
 ^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_class_variable_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 @@target &&= value # name `:@@target`
 ^^^^^^^^
```
*/
    pub name: pm_constant_id_t,
    /** ClassVariableAndWriteNode#name_loc

 Represents the Location of the variable name.

``` ruby
 @@target &&= value
 ^^^^^^^^
```
*/
    pub name_loc: pm_location_t,
    /** ClassVariableAndWriteNode#operator_loc

 Represents the Location of the `&&=` operator.

``` ruby
 @@target &&= value
          ^^^
```
*/
    pub operator_loc: pm_location_t,
    /** 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).

``` ruby
 @@target &&= value
              ^^^^^
```
*/
    pub value: *mut pm_node,
}
/** ClassVariableOperatorWriteNode

 Represents assigning to a class variable using an operator that isn't `=`.

``` ruby
 @@target += value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_class_variable_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ClassVariableOperatorWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** ClassVariableOperatorWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** ClassVariableOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** ClassVariableOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** ClassVariableOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
}
/** ClassVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a class variable.

``` ruby
 @@target ||= value
 ^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_class_variable_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ClassVariableOrWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** ClassVariableOrWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** ClassVariableOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** ClassVariableOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** ClassVariableReadNode

 Represents referencing a class variable.

``` ruby
 @@foo
 ^^^^^
```

 Type: ::PM_CLASS_VARIABLE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_class_variable_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 @@abc   # name `:@@abc`
```

``` ruby
 @@_test # name `:@@_test`
```
*/
    pub name: pm_constant_id_t,
}
/** ClassVariableTargetNode

 Represents writing to a class variable in a context that doesn't have an explicit value.

``` ruby
 @@foo, @@bar = baz
 ^^^^^  ^^^^^
```

 Type: ::PM_CLASS_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_class_variable_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ClassVariableTargetNode#name
*/
    pub name: pm_constant_id_t,
}
/** ClassVariableWriteNode

 Represents writing to a class variable.

``` ruby
 @@foo = 1
 ^^^^^^^^^
```

 Type: ::PM_CLASS_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_class_variable_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 @@abc = 123     # name `@@abc`
```

``` ruby
 @@_test = :test # name `@@_test`
```
*/
    pub name: pm_constant_id_t,
    /** ClassVariableWriteNode#name_loc

 The Location of the variable name.

``` ruby
 @@foo = :bar
 ^^^^^
```
*/
    pub name_loc: pm_location_t,
    /** 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).

``` ruby
 @@foo = :bar
         ^^^^
```

``` ruby
 @@_xyz = 123
          ^^^
```
*/
    pub value: *mut pm_node,
    /** ClassVariableWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 @@foo = :bar
       ^
```
*/
    pub operator_loc: pm_location_t,
}
/** ConstantAndWriteNode

 Represents the use of the `&&=` operator for assignment to a constant.

``` ruby
 Target &&= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantAndWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** ConstantAndWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** ConstantAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** ConstantAndWriteNode#value
*/
    pub value: *mut pm_node,
}
/** ConstantOperatorWriteNode

 Represents assigning to a constant using an operator that isn't `=`.

``` ruby
 Target += value
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantOperatorWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** ConstantOperatorWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** ConstantOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** ConstantOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** ConstantOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
}
/** ConstantOrWriteNode

 Represents the use of the `||=` operator for assignment to a constant.

``` ruby
 Target ||= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantOrWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** ConstantOrWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** ConstantOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** ConstantOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** ConstantPathAndWriteNode

 Represents the use of the `&&=` operator for assignment to a constant path.

``` ruby
 Parent::Child &&= value
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantPathAndWriteNode#target
*/
    pub target: *mut pm_constant_path_node,
    /** ConstantPathAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** ConstantPathAndWriteNode#value
*/
    pub value: *mut pm_node,
}
/** ConstantPathNode

 Represents accessing a constant through a path of `::` operators.

``` ruby
 Foo::Bar
 ^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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.

``` ruby
 Foo::Bar
 ^^^
```

``` ruby
 self::Test
 ^^^^
```

``` ruby
 a.b::C
 ^^^
```
*/
    pub parent: *mut pm_node,
    /** ConstantPathNode#name

 The name of the constant being accessed. This could be `nil` in the event of a syntax error.
*/
    pub name: pm_constant_id_t,
    /** ConstantPathNode#delimiter_loc

 The Location of the `::` delimiter.

``` ruby
 ::Foo
 ^^
```

``` ruby
 One::Two
    ^^
```
*/
    pub delimiter_loc: pm_location_t,
    /** ConstantPathNode#name_loc

 The Location of the name of the constant.

``` ruby
 ::Foo
   ^^^
```

``` ruby
 One::Two
      ^^^
```
*/
    pub name_loc: pm_location_t,
}
/** ConstantPathOperatorWriteNode

 Represents assigning to a constant path using an operator that isn't `=`.

``` ruby
 Parent::Child += value
 ^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantPathOperatorWriteNode#target
*/
    pub target: *mut pm_constant_path_node,
    /** ConstantPathOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** ConstantPathOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** ConstantPathOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
}
/** ConstantPathOrWriteNode

 Represents the use of the `||=` operator for assignment to a constant path.

``` ruby
 Parent::Child ||= value
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantPathOrWriteNode#target
*/
    pub target: *mut pm_constant_path_node,
    /** ConstantPathOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** ConstantPathOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** ConstantPathTargetNode

 Represents writing to a constant path in a context that doesn't have an explicit value.

``` ruby
 Foo::Foo, Bar::Bar = baz
 ^^^^^^^^  ^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantPathTargetNode#parent
*/
    pub parent: *mut pm_node,
    /** ConstantPathTargetNode#name
*/
    pub name: pm_constant_id_t,
    /** ConstantPathTargetNode#delimiter_loc
*/
    pub delimiter_loc: pm_location_t,
    /** ConstantPathTargetNode#name_loc
*/
    pub name_loc: pm_location_t,
}
/** ConstantPathWriteNode

 Represents writing to a constant path.

``` ruby
 ::Foo = 1
 ^^^^^^^^^
```

``` ruby
 Foo::Bar = 1
 ^^^^^^^^^^^^
```

``` ruby
 ::Foo::Bar = 1
 ^^^^^^^^^^^^^^
```

 Type: ::PM_CONSTANT_PATH_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_path_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantPathWriteNode#target

 A node representing the constant path being written to.

``` ruby
 Foo::Bar = 1
 ^^^^^^^^
```

``` ruby
 ::Foo = :abc
 ^^^^^
```
*/
    pub target: *mut pm_constant_path_node,
    /** ConstantPathWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 ::ABC = 123
       ^
```
*/
    pub operator_loc: pm_location_t,
    /** 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).

``` ruby
 FOO::BAR = :abc
            ^^^^
```
*/
    pub value: *mut pm_node,
}
/** ConstantReadNode

 Represents referencing a constant.

``` ruby
 Foo
 ^^^
```

 Type: ::PM_CONSTANT_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_constant_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantReadNode#name

 The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).

``` ruby
 X              # name `:X`
```

``` ruby
 SOME_CONSTANT  # name `:SOME_CONSTANT`
```
*/
    pub name: pm_constant_id_t,
}
/** ConstantTargetNode

 Represents writing to a constant in a context that doesn't have an explicit value.

``` ruby
 Foo, Bar = baz
 ^^^  ^^^
```

 Type: ::PM_CONSTANT_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_constant_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantTargetNode#name
*/
    pub name: pm_constant_id_t,
}
/** ConstantWriteNode

 Represents writing to a constant.

``` ruby
 Foo = 1
 ^^^^^^^
```

 Type: ::PM_CONSTANT_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_constant_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ConstantWriteNode#name

 The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).

``` ruby
 Foo = :bar # name `:Foo`
```

``` ruby
 XYZ = 1    # name `:XYZ`
```
*/
    pub name: pm_constant_id_t,
    /** ConstantWriteNode#name_loc

 The Location of the constant name.

``` ruby
 FOO = 1
 ^^^
```
*/
    pub name_loc: pm_location_t,
    /** 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).

``` ruby
 FOO = :bar
       ^^^^
```

``` ruby
 MyClass = Class.new
           ^^^^^^^^^
```
*/
    pub value: *mut pm_node,
    /** ConstantWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 FOO = :bar
     ^
```
*/
    pub operator_loc: pm_location_t,
}
/** DefNode

 Represents a method definition.

``` ruby
 def method
 end
 ^^^^^^^^^^
```

 Type: ::PM_DEF_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_def_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** DefNode#name
*/
    pub name: pm_constant_id_t,
    /** DefNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** DefNode#receiver
*/
    pub receiver: *mut pm_node,
    /** DefNode#parameters
*/
    pub parameters: *mut pm_parameters_node,
    /** DefNode#body
*/
    pub body: *mut pm_node,
    /** DefNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** DefNode#def_keyword_loc
*/
    pub def_keyword_loc: pm_location_t,
    /** DefNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** DefNode#lparen_loc
*/
    pub lparen_loc: pm_location_t,
    /** DefNode#rparen_loc
*/
    pub rparen_loc: pm_location_t,
    /** DefNode#equal_loc
*/
    pub equal_loc: pm_location_t,
    /** DefNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
}
/** DefinedNode

 Represents the use of the `defined?` keyword.

``` ruby
 defined?(a)
 ^^^^^^^^^^^
```

 Type: ::PM_DEFINED_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_defined_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** DefinedNode#lparen_loc
*/
    pub lparen_loc: pm_location_t,
    /** DefinedNode#value
*/
    pub value: *mut pm_node,
    /** DefinedNode#rparen_loc
*/
    pub rparen_loc: pm_location_t,
    /** DefinedNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** ElseNode

 Represents an `else` clause in a `case`, `if`, or `unless` statement.

``` ruby
 if a then b else c end
             ^^^^^^^^^^
```

 Type: ::PM_ELSE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_else_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ElseNode#else_keyword_loc
*/
    pub else_keyword_loc: pm_location_t,
    /** ElseNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** ElseNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
}
/** EmbeddedStatementsNode

 Represents an interpolated set of statements.

``` ruby
 "foo #{bar}"
      ^^^^^^
```

 Type: ::PM_EMBEDDED_STATEMENTS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_embedded_statements_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** EmbeddedStatementsNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** EmbeddedStatementsNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** EmbeddedStatementsNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** EmbeddedVariableNode

 Represents an interpolated variable.

``` ruby
 "foo #@bar"
      ^^^^^
```

 Type: ::PM_EMBEDDED_VARIABLE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_embedded_variable_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** EmbeddedVariableNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** EmbeddedVariableNode#variable
*/
    pub variable: *mut pm_node,
}
/** EnsureNode

 Represents an `ensure` clause in a `begin` statement.

``` ruby
 begin
   foo
 ensure
 ^^^^^^
   bar
 end
```

 Type: ::PM_ENSURE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_ensure_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** EnsureNode#ensure_keyword_loc
*/
    pub ensure_keyword_loc: pm_location_t,
    /** EnsureNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** EnsureNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
}
/** ErrorRecoveryNode

 Represents a node that is either missing or unexpected and results in a syntax error.

 Type: ::PM_ERROR_RECOVERY_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_error_recovery_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ErrorRecoveryNode#unexpected

 The unexpected node that was found in the tree, if there was one.
*/
    pub unexpected: *mut pm_node,
}
/** FalseNode

 Represents the use of the literal `false` keyword.

``` ruby
 false
 ^^^^^
```

 Type: ::PM_FALSE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_false_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** FindPatternNode

 Represents a find pattern in pattern matching.

``` ruby
 foo in *bar, baz, *qux
        ^^^^^^^^^^^^^^^
```

``` ruby
 foo in [*bar, baz, *qux]
        ^^^^^^^^^^^^^^^^^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
        ^^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo => *bar, baz, *qux
        ^^^^^^^^^^^^^^^
```

 Type: ::PM_FIND_PATTERN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_find_pattern_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** FindPatternNode#constant

 Represents the optional constant preceding the pattern

``` ruby
 foo in Foo(*bar, baz, *qux)
        ^^^
```
*/
    pub constant: *mut pm_node,
    /** FindPatternNode#left

 Represents the first wildcard node in the pattern.

``` ruby
 foo in *bar, baz, *qux
        ^^^^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
            ^^^^
```
*/
    pub left: *mut pm_splat_node,
    /** FindPatternNode#requireds

 Represents the nodes in between the wildcards.

``` ruby
 foo in *bar, baz, *qux
              ^^^
```

``` ruby
 foo in Foo(*bar, baz, 1, *qux)
                  ^^^^^^
```
*/
    pub requireds: pm_node_list,
    /** FindPatternNode#right

 Represents the second wildcard node in the pattern.

``` ruby
 foo in *bar, baz, *qux
                   ^^^^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
                       ^^^^
```
*/
    pub right: *mut pm_splat_node,
    /** FindPatternNode#opening_loc

 The Location of the opening brace.

``` ruby
 foo in [*bar, baz, *qux]
        ^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
           ^
```
*/
    pub opening_loc: pm_location_t,
    /** FindPatternNode#closing_loc

 The Location of the closing brace.

``` ruby
 foo in [*bar, baz, *qux]
                        ^
```

``` ruby
 foo in Foo(*bar, baz, *qux)
                           ^
```
*/
    pub closing_loc: pm_location_t,
}
/** FlipFlopNode

 Represents the use of the `..` or `...` operators to create flip flops.

``` ruby
 baz if foo .. bar
        ^^^^^^^^^^
```

 Type: ::PM_FLIP_FLOP_NODE

 Flags (#pm_range_flags):
 * ::PM_RANGE_FLAGS_EXCLUDE_END

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_flip_flop_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** FlipFlopNode#left
*/
    pub left: *mut pm_node,
    /** FlipFlopNode#right
*/
    pub right: *mut pm_node,
    /** FlipFlopNode#operator_loc
*/
    pub operator_loc: pm_location_t,
}
/** FloatNode

 Represents a floating point number literal.

``` ruby
 1.0
 ^^^
```

 Type: ::PM_FLOAT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_float_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** FloatNode#value

 The value of the floating point number as a Float.
*/
    pub value: f64,
}
/** ForNode

 Represents the use of the `for` keyword.

``` ruby
 for i in a end
 ^^^^^^^^^^^^^^
```

 Type: ::PM_FOR_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_for_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ForNode#index

 The index expression for `for` loops.

``` ruby
 for i in a end
     ^
```
*/
    pub index: *mut pm_node,
    /** ForNode#collection

 The collection to iterate over.

``` ruby
 for i in a end
          ^
```
*/
    pub collection: *mut pm_node,
    /** ForNode#statements

 Represents the body of statements to execute for each iteration of the loop.

``` ruby
 for i in a
   foo(i)
   ^^^^^^
 end
```
*/
    pub statements: *mut pm_statements_node,
    /** ForNode#for_keyword_loc

 The Location of the `for` keyword.

``` ruby
 for i in a end
 ^^^
```
*/
    pub for_keyword_loc: pm_location_t,
    /** ForNode#in_keyword_loc

 The Location of the `in` keyword.

``` ruby
 for i in a end
       ^^
```
*/
    pub in_keyword_loc: pm_location_t,
    /** ForNode#do_keyword_loc

 The Location of the `do` keyword, if present.

``` ruby
 for i in a do end
            ^^
```
*/
    pub do_keyword_loc: pm_location_t,
    /** ForNode#end_keyword_loc

 The Location of the `end` keyword.

``` ruby
 for i in a end
            ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** ForwardingArgumentsNode

 Represents forwarding all arguments to this method to another method.

``` ruby
 def foo(...)
   bar(...)
       ^^^
 end
```

 Type: ::PM_FORWARDING_ARGUMENTS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_forwarding_arguments_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** ForwardingParameterNode

 Represents the use of the forwarding parameter in a method, block, or lambda declaration.

``` ruby
 def foo(...)
         ^^^
 end
```

 Type: ::PM_FORWARDING_PARAMETER_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_forwarding_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** ForwardingSuperNode

 Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.

``` ruby
 super
 ^^^^^
```

``` ruby
 super { 123 }
 ^^^^^^^^^^^^^
```

 If it has any other arguments, it would be a `SuperNode` instead.

 Type: ::PM_FORWARDING_SUPER_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_forwarding_super_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ForwardingSuperNode#keyword_loc

 super
 ^^^^^

 super { 123 }
 ^^^^^
*/
    pub keyword_loc: pm_location_t,
    /** ForwardingSuperNode#block

 All other arguments are forwarded as normal, except the original block is replaced with the new block.
*/
    pub block: *mut pm_block_node,
}
/** GlobalVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a global variable.

``` ruby
 $target &&= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_global_variable_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** GlobalVariableAndWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** GlobalVariableAndWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** GlobalVariableAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** GlobalVariableAndWriteNode#value
*/
    pub value: *mut pm_node,
}
/** GlobalVariableOperatorWriteNode

 Represents assigning to a global variable using an operator that isn't `=`.

``` ruby
 $target += value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_global_variable_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** GlobalVariableOperatorWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** GlobalVariableOperatorWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** GlobalVariableOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** GlobalVariableOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** GlobalVariableOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
}
/** GlobalVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a global variable.

``` ruby
 $target ||= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_global_variable_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** GlobalVariableOrWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** GlobalVariableOrWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** GlobalVariableOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** GlobalVariableOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** GlobalVariableReadNode

 Represents referencing a global variable.

``` ruby
 $foo
 ^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_global_variable_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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.

``` ruby
 $foo   # name `:$foo`
```

``` ruby
 $_Test # name `:$_Test`
```
*/
    pub name: pm_constant_id_t,
}
/** GlobalVariableTargetNode

 Represents writing to a global variable in a context that doesn't have an explicit value.

``` ruby
 $foo, $bar = baz
 ^^^^  ^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_global_variable_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** GlobalVariableTargetNode#name
*/
    pub name: pm_constant_id_t,
}
/** GlobalVariableWriteNode

 Represents writing to a global variable.

``` ruby
 $foo = 1
 ^^^^^^^^
```

 Type: ::PM_GLOBAL_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_global_variable_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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.

``` ruby
 $foo = :bar  # name `:$foo`
```

``` ruby
 $_Test = 123 # name `:$_Test`
```
*/
    pub name: pm_constant_id_t,
    /** GlobalVariableWriteNode#name_loc

 The Location of the global variable's name.

``` ruby
 $foo = :bar
 ^^^^
```
*/
    pub name_loc: pm_location_t,
    /** 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).

``` ruby
 $foo = :bar
        ^^^^
```

``` ruby
 $-xyz = 123
         ^^^
```
*/
    pub value: *mut pm_node,
    /** GlobalVariableWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 $foo = :bar
      ^
```
*/
    pub operator_loc: pm_location_t,
}
/** HashNode

 Represents a hash literal.

``` ruby
 { a => b }
 ^^^^^^^^^^
```

 Type: ::PM_HASH_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_hash_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** HashNode#opening_loc

 The Location of the opening brace.

``` ruby
 { a => b }
 ^
```
*/
    pub opening_loc: pm_location_t,
    /** HashNode#elements

 The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s.

``` ruby
 { a: b }
   ^^^^
```

``` ruby
 { **foo }
   ^^^^^
```
*/
    pub elements: pm_node_list,
    /** HashNode#closing_loc

 The Location of the closing brace.

``` ruby
 { a => b }
          ^
```
*/
    pub closing_loc: pm_location_t,
}
/** HashPatternNode

 Represents a hash pattern in pattern matching.

``` ruby
 foo => { a: 1, b: 2 }
        ^^^^^^^^^^^^^^
```

``` ruby
 foo => { a: 1, b: 2, **c }
        ^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo => Bar[a: 1, b: 2]
        ^^^^^^^^^^^^^^^
```

``` ruby
 foo in { a: 1, b: 2 }
        ^^^^^^^^^^^^^^
```

 Type: ::PM_HASH_PATTERN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_hash_pattern_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** HashPatternNode#constant

 Represents the optional constant preceding the Hash.

``` ruby
 foo => Bar[a: 1, b: 2]
      ^^^
```

``` ruby
 foo => Bar::Baz[a: 1, b: 2]
      ^^^^^^^^
```
*/
    pub constant: *mut pm_node,
    /** HashPatternNode#elements

 Represents the explicit named hash keys and values.

``` ruby
 foo => { a: 1, b:, ** }
          ^^^^^^^^
```
*/
    pub elements: pm_node_list,
    /** 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`.

``` ruby
 foo => { a: 1, b:, **c }
                    ^^^
```

``` ruby
 foo => { a: 1, b:, ** }
                    ^^
```

``` ruby
 foo => { a: 1, b:, **nil }
                    ^^^^^
```
*/
    pub rest: *mut pm_node,
    /** HashPatternNode#opening_loc

 The Location of the opening brace.

``` ruby
 foo => { a: 1 }
        ^
```

``` ruby
 foo => Bar[a: 1]
           ^
```
*/
    pub opening_loc: pm_location_t,
    /** HashPatternNode#closing_loc

 The Location of the closing brace.

``` ruby
 foo => { a: 1 }
               ^
```

``` ruby
 foo => Bar[a: 1]
                ^
```
*/
    pub closing_loc: pm_location_t,
}
/** IfNode

 Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.

``` ruby
 bar if foo
 ^^^^^^^^^^
```

``` ruby
 if foo then bar end
 ^^^^^^^^^^^^^^^^^^^
```

``` ruby
 foo ? bar : baz
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_IF_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_if_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IfNode#if_keyword_loc

 The Location of the `if` keyword if present.

``` ruby
 bar if foo
     ^^
```

 The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
*/
    pub if_keyword_loc: pm_location_t,
    /** IfNode#predicate

 The node for the condition the `IfNode` is testing.

``` ruby
 if foo
    ^^^
   bar
 end
```

``` ruby
 bar if foo
        ^^^
```

``` ruby
 foo ? bar : baz
 ^^^
```
*/
    pub predicate: *mut pm_node,
    /** IfNode#then_keyword_loc

 The Location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.

``` ruby
 if foo then bar end
        ^^^^
```

``` ruby
 a ? b : c
   ^
```
*/
    pub then_keyword_loc: pm_location_t,
    /** 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.

``` ruby
 if foo
   bar
   ^^^
   baz
   ^^^
 end
```
*/
    pub statements: *mut pm_statements_node,
    /** IfNode#subsequent

 Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.

``` ruby
 if foo
   bar
 elsif baz
 ^^^^^^^^^
   qux
   ^^^
 end
 ^^^
```

``` ruby
 if foo then bar else baz end
                 ^^^^^^^^^^^^
```
*/
    pub subsequent: *mut pm_node,
    /** IfNode#end_keyword_loc

 The Location of the `end` keyword if present, `nil` otherwise.

``` ruby
 if foo
   bar
 end
 ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** ImaginaryNode

 Represents an imaginary number literal.

``` ruby
 1.0i
 ^^^^
```

 Type: ::PM_IMAGINARY_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_imaginary_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ImaginaryNode#numeric
*/
    pub numeric: *mut pm_node,
}
/** ImplicitNode

 Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.

``` ruby
 { foo: }
   ^^^^
```

``` ruby
 { Foo: }
   ^^^^
```

``` ruby
 foo in { bar: }
          ^^^^
```

 Type: ::PM_IMPLICIT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_implicit_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ImplicitNode#value
*/
    pub value: *mut pm_node,
}
/** ImplicitRestNode

 Represents using a trailing comma to indicate an implicit rest parameter.

``` ruby
 foo { |bar,| }
           ^
```

``` ruby
 foo in [bar,]
            ^
```

``` ruby
 for foo, in bar do end
        ^
```

``` ruby
 foo, = bar
    ^
```

 Type: ::PM_IMPLICIT_REST_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_implicit_rest_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** InNode

 Represents the use of the `in` keyword in a case statement.

``` ruby
 case a; in b then c end
         ^^^^^^^^^^^
```

 Type: ::PM_IN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_in_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InNode#pattern
*/
    pub pattern: *mut pm_node,
    /** InNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** InNode#in_keyword_loc
*/
    pub in_keyword_loc: pm_location_t,
    /** InNode#then_keyword_loc
*/
    pub then_keyword_loc: pm_location_t,
}
/** IndexAndWriteNode

 Represents the use of the `&&=` operator on a call to the `[]` method.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_index_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IndexAndWriteNode#receiver
*/
    pub receiver: *mut pm_node,
    /** IndexAndWriteNode#call_operator_loc
*/
    pub call_operator_loc: pm_location_t,
    /** IndexAndWriteNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** IndexAndWriteNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** IndexAndWriteNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** IndexAndWriteNode#block
*/
    pub block: *mut pm_block_argument_node,
    /** IndexAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** IndexAndWriteNode#value
*/
    pub value: *mut pm_node,
}
/** IndexOperatorWriteNode

 Represents the use of an assignment operator on a call to `[]`.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_index_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IndexOperatorWriteNode#receiver
*/
    pub receiver: *mut pm_node,
    /** IndexOperatorWriteNode#call_operator_loc
*/
    pub call_operator_loc: pm_location_t,
    /** IndexOperatorWriteNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** IndexOperatorWriteNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** IndexOperatorWriteNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** IndexOperatorWriteNode#block
*/
    pub block: *mut pm_block_argument_node,
    /** IndexOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
    /** IndexOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** IndexOperatorWriteNode#value
*/
    pub value: *mut pm_node,
}
/** IndexOrWriteNode

 Represents the use of the `||=` operator on a call to `[]`.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_index_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IndexOrWriteNode#receiver
*/
    pub receiver: *mut pm_node,
    /** IndexOrWriteNode#call_operator_loc
*/
    pub call_operator_loc: pm_location_t,
    /** IndexOrWriteNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** IndexOrWriteNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** IndexOrWriteNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** IndexOrWriteNode#block
*/
    pub block: *mut pm_block_argument_node,
    /** IndexOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** IndexOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** IndexTargetNode

 Represents assigning to an index.

``` ruby
 foo[bar], = 1
 ^^^^^^^^
```

``` ruby
 begin
 rescue => foo[bar]
           ^^^^^^^^
 end
```

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_index_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IndexTargetNode#receiver
*/
    pub receiver: *mut pm_node,
    /** IndexTargetNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** IndexTargetNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** IndexTargetNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** IndexTargetNode#block
*/
    pub block: *mut pm_block_argument_node,
}
/** InstanceVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to an instance variable.

``` ruby
 @target &&= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_instance_variable_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InstanceVariableAndWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** InstanceVariableAndWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** InstanceVariableAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** InstanceVariableAndWriteNode#value
*/
    pub value: *mut pm_node,
}
/** InstanceVariableOperatorWriteNode

 Represents assigning to an instance variable using an operator that isn't `=`.

``` ruby
 @target += value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_instance_variable_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InstanceVariableOperatorWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** InstanceVariableOperatorWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** InstanceVariableOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** InstanceVariableOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** InstanceVariableOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
}
/** InstanceVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to an instance variable.

``` ruby
 @target ||= value
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_instance_variable_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InstanceVariableOrWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** InstanceVariableOrWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** InstanceVariableOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** InstanceVariableOrWriteNode#value
*/
    pub value: *mut pm_node,
}
/** InstanceVariableReadNode

 Represents referencing an instance variable.

``` ruby
 @foo
 ^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_instance_variable_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 @x     # name `:@x`
```

``` ruby
 @_test # name `:@_test`
```
*/
    pub name: pm_constant_id_t,
}
/** InstanceVariableTargetNode

 Represents writing to an instance variable in a context that doesn't have an explicit value.

``` ruby
 @foo, @bar = baz
 ^^^^  ^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_instance_variable_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InstanceVariableTargetNode#name
*/
    pub name: pm_constant_id_t,
}
/** InstanceVariableWriteNode

 Represents writing to an instance variable.

``` ruby
 @foo = 1
 ^^^^^^^^
```

 Type: ::PM_INSTANCE_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_instance_variable_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 @x = :y       # name `:@x`
```

``` ruby
 @_foo = "bar" # name `@_foo`
```
*/
    pub name: pm_constant_id_t,
    /** InstanceVariableWriteNode#name_loc

 The Location of the variable name.

``` ruby
 @_x = 1
 ^^^
```
*/
    pub name_loc: pm_location_t,
    /** 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).

``` ruby
 @foo = :bar
        ^^^^
```

``` ruby
 @_x = 1234
       ^^^^
```
*/
    pub value: *mut pm_node,
    /** InstanceVariableWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 @x = y
    ^
```
*/
    pub operator_loc: pm_location_t,
}
/** IntegerNode

 Represents an integer number literal.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_integer_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** IntegerNode#value

 The value of the integer literal as a number.
*/
    pub value: pm_integer_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.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_interpolated_match_last_line_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InterpolatedMatchLastLineNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** InterpolatedMatchLastLineNode#parts
*/
    pub parts: pm_node_list,
    /** InterpolatedMatchLastLineNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** InterpolatedRegularExpressionNode

 Represents a regular expression literal that contains interpolation.

``` ruby
 /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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_interpolated_regular_expression_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InterpolatedRegularExpressionNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** InterpolatedRegularExpressionNode#parts
*/
    pub parts: pm_node_list,
    /** InterpolatedRegularExpressionNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** InterpolatedStringNode

 Represents a string literal that contains interpolation.

``` ruby
 "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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_interpolated_string_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InterpolatedStringNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** InterpolatedStringNode#parts
*/
    pub parts: pm_node_list,
    /** InterpolatedStringNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** InterpolatedSymbolNode

 Represents a symbol literal that contains interpolation.

``` ruby
 :"foo #{bar} baz"
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_INTERPOLATED_SYMBOL_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_interpolated_symbol_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InterpolatedSymbolNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** InterpolatedSymbolNode#parts
*/
    pub parts: pm_node_list,
    /** InterpolatedSymbolNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** InterpolatedXStringNode

 Represents an xstring literal that contains interpolation.

``` ruby
 `foo #{bar} baz`
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_INTERPOLATED_X_STRING_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_interpolated_x_string_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** InterpolatedXStringNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** InterpolatedXStringNode#parts
*/
    pub parts: pm_node_list,
    /** InterpolatedXStringNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** ItLocalVariableReadNode

 Represents reading from the implicit `it` local variable.

``` ruby
 -> { it }
      ^^
```

 Type: ::PM_IT_LOCAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_it_local_variable_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** ItParametersNode

 Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.

``` ruby
 -> { it + it }
 ^^^^^^^^^^^^^^
```

 Type: ::PM_IT_PARAMETERS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_it_parameters_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** KeywordHashNode

 Represents a hash literal without opening and closing braces.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_keyword_hash_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** KeywordHashNode#elements
*/
    pub elements: pm_node_list,
}
/** KeywordRestParameterNode

 Represents a keyword rest parameter to a method, block, or lambda definition.

``` ruby
 def a(**b)
       ^^^
 end
```

 Type: ::PM_KEYWORD_REST_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_keyword_rest_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** KeywordRestParameterNode#name
*/
    pub name: pm_constant_id_t,
    /** KeywordRestParameterNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** KeywordRestParameterNode#operator_loc
*/
    pub operator_loc: pm_location_t,
}
/** LambdaNode

 Represents using a lambda literal (not the lambda method call).

``` ruby
 ->(value) { value * 2 }
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_LAMBDA_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_lambda_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LambdaNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** LambdaNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** LambdaNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** LambdaNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** LambdaNode#parameters
*/
    pub parameters: *mut pm_node,
    /** LambdaNode#body
*/
    pub body: *mut pm_node,
}
/** LocalVariableAndWriteNode

 Represents the use of the `&&=` operator for assignment to a local variable.

``` ruby
 target &&= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_AND_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_local_variable_and_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableAndWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** LocalVariableAndWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** LocalVariableAndWriteNode#value
*/
    pub value: *mut pm_node,
    /** LocalVariableAndWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** LocalVariableAndWriteNode#depth
*/
    pub depth: u32,
}
/** LocalVariableOperatorWriteNode

 Represents assigning to a local variable using an operator that isn't `=`.

``` ruby
 target += value
 ^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_local_variable_operator_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableOperatorWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** LocalVariableOperatorWriteNode#binary_operator_loc
*/
    pub binary_operator_loc: pm_location_t,
    /** LocalVariableOperatorWriteNode#value
*/
    pub value: *mut pm_node,
    /** LocalVariableOperatorWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** LocalVariableOperatorWriteNode#binary_operator
*/
    pub binary_operator: pm_constant_id_t,
    /** LocalVariableOperatorWriteNode#depth
*/
    pub depth: u32,
}
/** LocalVariableOrWriteNode

 Represents the use of the `||=` operator for assignment to a local variable.

``` ruby
 target ||= value
 ^^^^^^^^^^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_OR_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_local_variable_or_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableOrWriteNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** LocalVariableOrWriteNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** LocalVariableOrWriteNode#value
*/
    pub value: *mut pm_node,
    /** LocalVariableOrWriteNode#name
*/
    pub name: pm_constant_id_t,
    /** LocalVariableOrWriteNode#depth
*/
    pub depth: u32,
}
/** 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.

``` ruby
 foo
 ^^^
```

 Type: ::PM_LOCAL_VARIABLE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_local_variable_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableReadNode#name

 The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).

``` ruby
 x      # name `:x`
```

``` ruby
 _Test  # name `:_Test`
```

 Note that this can also be an underscore followed by a number for the default block parameters.

``` ruby
 _1     # name `:_1`
```
*/
    pub name: pm_constant_id_t,
    /** LocalVariableReadNode#depth

 The number of visible scopes that should be searched to find the origin of this local variable.

``` ruby
 foo = 1; foo # depth 0
```

``` ruby
 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).
*/
    pub depth: u32,
}
/** LocalVariableTargetNode

 Represents writing to a local variable in a context that doesn't have an explicit value.

``` ruby
 foo, bar = baz
 ^^^  ^^^
```

``` ruby
 foo => baz
        ^^^
```

 Type: ::PM_LOCAL_VARIABLE_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_local_variable_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableTargetNode#name
*/
    pub name: pm_constant_id_t,
    /** LocalVariableTargetNode#depth
*/
    pub depth: u32,
}
/** LocalVariableWriteNode

 Represents writing to a local variable.

``` ruby
 foo = 1
 ^^^^^^^
```

 Type: ::PM_LOCAL_VARIABLE_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_local_variable_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** LocalVariableWriteNode#name

 The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).

``` ruby
 foo = :bar # name `:foo`
```

``` ruby
 abc = 123  # name `:abc`
```
*/
    pub name: pm_constant_id_t,
    /** LocalVariableWriteNode#depth

 The number of semantic scopes we have to traverse to find the declaration of this variable.

``` ruby
 foo = 1         # depth 0
```

``` ruby
 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).
*/
    pub depth: u32,
    /** LocalVariableWriteNode#name_loc

 The Location of the variable name.

``` ruby
 foo = :bar
 ^^^
```
*/
    pub name_loc: pm_location_t,
    /** 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).

``` ruby
 foo = :bar
       ^^^^
```

``` ruby
 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.

``` ruby
 foo = foo
```
*/
    pub value: *mut pm_node,
    /** LocalVariableWriteNode#operator_loc

 The Location of the `=` operator.

``` ruby
 x = :y
   ^
```
*/
    pub operator_loc: pm_location_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.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_match_last_line_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MatchLastLineNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** MatchLastLineNode#content_loc
*/
    pub content_loc: pm_location_t,
    /** MatchLastLineNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** MatchLastLineNode#unescaped
*/
    pub unescaped: pm_string_t,
}
/** MatchPredicateNode

 Represents the use of the modifier `in` operator.

``` ruby
 foo in bar
 ^^^^^^^^^^
```

 Type: ::PM_MATCH_PREDICATE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_match_predicate_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MatchPredicateNode#value
*/
    pub value: *mut pm_node,
    /** MatchPredicateNode#pattern
*/
    pub pattern: *mut pm_node,
    /** MatchPredicateNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** MatchRequiredNode

 Represents the use of the `=>` operator.

``` ruby
 foo => bar
 ^^^^^^^^^^
```

 Type: ::PM_MATCH_REQUIRED_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_match_required_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MatchRequiredNode#value

 Represents the left-hand side of the operator.

``` ruby
 foo => bar
 ^^^
```
*/
    pub value: *mut pm_node,
    /** 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`.

``` ruby
 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.

``` ruby
 foo => [a]
        ^^^
```

``` ruby
 foo => a, b
        ^^^^
```

``` ruby
 foo => Bar[a, b]
        ^^^^^^^^^
```

 If the array pattern contains at least two wildcard matches, a `FindPatternNode` is created instead.

``` ruby
 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`.

``` ruby
 foo => { a: 1, b: }
```

``` ruby
 foo => Bar[a: 1, b:]
```

``` ruby
 foo => Bar[**]
```

 To use any variable that needs run time evaluation, pinning is required. This results in a `PinnedVariableNode`

``` ruby
 foo => ^a
        ^^
```

 Similar, any expression can be used with pinning. This results in a `PinnedExpressionNode`.

``` ruby
 foo => ^(a + 1)
```

 Anything else will result in the regular node for that expression, for example a `ConstantReadNode`.

``` ruby
 foo => CONST
```
*/
    pub pattern: *mut pm_node,
    /** MatchRequiredNode#operator_loc

 The Location of the operator.

``` ruby
 foo => bar
     ^^
```
*/
    pub operator_loc: pm_location_t,
}
/** MatchWriteNode

 Represents writing local variables using a regular expression match with named capture groups.

``` ruby
 /(?<foo>bar)/ =~ baz
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_MATCH_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_match_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MatchWriteNode#call
*/
    pub call: *mut pm_call_node,
    /** MatchWriteNode#targets
*/
    pub targets: pm_node_list,
}
/** ModuleNode

 Represents a module declaration involving the `module` keyword.

``` ruby
 module Foo end
 ^^^^^^^^^^^^^^
```

 Type: ::PM_MODULE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_module_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ModuleNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** ModuleNode#module_keyword_loc
*/
    pub module_keyword_loc: pm_location_t,
    /** ModuleNode#constant_path
*/
    pub constant_path: *mut pm_node,
    /** ModuleNode#body
*/
    pub body: *mut pm_node,
    /** ModuleNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
    /** ModuleNode#name
*/
    pub name: pm_constant_id_t,
}
/** MultiTargetNode

 Represents a multi-target expression.

``` ruby
 a, (b, c) = 1, 2, 3
    ^^^^^^
```

 This can be a part of `MultiWriteNode` as above, or the target of a `for` loop

``` ruby
 for a, b in [[1, 2], [3, 4]]
     ^^^^
```

 Type: ::PM_MULTI_TARGET_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_multi_target_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MultiTargetNode#lefts

 Represents the targets expressions before a splat node.

``` ruby
 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.

``` ruby
 a, (b, c) = 1, 2, 3, 4, 5
     ^^^^
```
*/
    pub lefts: pm_node_list,
    /** MultiTargetNode#rest

 Represents a splat node in the target expression.

``` ruby
 a, (b, *c) = 1, 2, 3, 4
        ^^
```

 The variable can be empty, this results in a `SplatNode` with a `nil` expression field.

``` ruby
 a, (b, *) = 1, 2, 3, 4
        ^
```

 If the `*` is omitted, this field will contain an `ImplicitRestNode`

``` ruby
 a, (b,) = 1, 2, 3, 4
      ^
```
*/
    pub rest: *mut pm_node,
    /** MultiTargetNode#rights

 Represents the targets expressions after a splat node.

``` ruby
 a, (*, b, c) = 1, 2, 3, 4, 5
        ^^^^
```
*/
    pub rights: pm_node_list,
    /** MultiTargetNode#lparen_loc

 The Location of the opening parenthesis.

``` ruby
 a, (b, c) = 1, 2, 3
    ^
```
*/
    pub lparen_loc: pm_location_t,
    /** MultiTargetNode#rparen_loc

 The Location of the closing parenthesis.

``` ruby
 a, (b, c) = 1, 2, 3
         ^
```
*/
    pub rparen_loc: pm_location_t,
}
/** MultiWriteNode

 Represents a write to a multi-target expression.

``` ruby
 a, b, c = 1, 2, 3
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_MULTI_WRITE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_multi_write_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** MultiWriteNode#lefts

 Represents the targets expressions before a splat node.

``` ruby
 a, b, * = 1, 2, 3, 4, 5
 ^^^^
```

 The splat node can be absent, in that case all target expressions are in the left field.

``` ruby
 a, b, c = 1, 2, 3, 4, 5
 ^^^^^^^
```
*/
    pub lefts: pm_node_list,
    /** MultiWriteNode#rest

 Represents a splat node in the target expression.

``` ruby
 a, b, *c = 1, 2, 3, 4
       ^^
```

 The variable can be empty, this results in a `SplatNode` with a `nil` expression field.

``` ruby
 a, b, * = 1, 2, 3, 4
       ^
```

 If the `*` is omitted, this field will contain an `ImplicitRestNode`

``` ruby
 a, b, = 1, 2, 3, 4
     ^
```
*/
    pub rest: *mut pm_node,
    /** MultiWriteNode#rights

 Represents the targets expressions after a splat node.

``` ruby
 a, *, b, c = 1, 2, 3, 4, 5
       ^^^^
```
*/
    pub rights: pm_node_list,
    /** MultiWriteNode#lparen_loc

 The Location of the opening parenthesis.

``` ruby
 (a, b, c) = 1, 2, 3
 ^
```
*/
    pub lparen_loc: pm_location_t,
    /** MultiWriteNode#rparen_loc

 The Location of the closing parenthesis.

``` ruby
 (a, b, c) = 1, 2, 3
         ^
```
*/
    pub rparen_loc: pm_location_t,
    /** MultiWriteNode#operator_loc

 The Location of the operator.

``` ruby
 a, b, c = 1, 2, 3
         ^
```
*/
    pub operator_loc: pm_location_t,
    /** 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).

``` ruby
 a, b, c = 1, 2, 3
           ^^^^^^^
```
*/
    pub value: *mut pm_node,
}
/** NextNode

 Represents the use of the `next` keyword.

``` ruby
 next 1
 ^^^^^^
```

 Type: ::PM_NEXT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_next_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** NextNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** NextNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** NilNode

 Represents the use of the `nil` keyword.

``` ruby
 nil
 ^^^
```

 Type: ::PM_NIL_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_nil_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** NoBlockParameterNode

 Represents the use of `&nil` inside method arguments.

``` ruby
 def a(&nil)
       ^^^^
 end
```

 Type: ::PM_NO_BLOCK_PARAMETER_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_no_block_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** NoBlockParameterNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** NoBlockParameterNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** NoKeywordsParameterNode

 Represents the use of `**nil` inside method arguments.

``` ruby
 def a(**nil)
       ^^^^^
 end
```

 Type: ::PM_NO_KEYWORDS_PARAMETER_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_no_keywords_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** NoKeywordsParameterNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** NoKeywordsParameterNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** NumberedParametersNode

 Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.

``` ruby
 -> { _1 + _2 }
 ^^^^^^^^^^^^^^
```

 Type: ::PM_NUMBERED_PARAMETERS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_numbered_parameters_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** NumberedParametersNode#maximum
*/
    pub maximum: u8,
}
/** NumberedReferenceReadNode

 Represents reading a numbered reference to a capture in the previous match.

``` ruby
 $1
 ^^
```

 Type: ::PM_NUMBERED_REFERENCE_READ_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_numbered_reference_read_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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`.

``` ruby
 $1          # number `1`
```

``` ruby
 $5432       # number `5432`
```

``` ruby
 $4294967296 # number `0`
```
*/
    pub number: u32,
}
/** OptionalKeywordParameterNode

 Represents an optional keyword parameter to a method, block, or lambda definition.

``` ruby
 def a(b: 1)
       ^^^^
 end
```

 Type: ::PM_OPTIONAL_KEYWORD_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_optional_keyword_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** OptionalKeywordParameterNode#name
*/
    pub name: pm_constant_id_t,
    /** OptionalKeywordParameterNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** OptionalKeywordParameterNode#value
*/
    pub value: *mut pm_node,
}
/** OptionalParameterNode

 Represents an optional parameter to a method, block, or lambda definition.

``` ruby
 def a(b = 1)
       ^^^^^
 end
```

 Type: ::PM_OPTIONAL_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_optional_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** OptionalParameterNode#name
*/
    pub name: pm_constant_id_t,
    /** OptionalParameterNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** OptionalParameterNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** OptionalParameterNode#value
*/
    pub value: *mut pm_node,
}
/** OrNode

 Represents the use of the `||` operator or the `or` keyword.

``` ruby
 left or right
 ^^^^^^^^^^^^^
```

 Type: ::PM_OR_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_or_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 left or right
 ^^^^
```

``` ruby
 1 || 2
 ^
```
*/
    pub left: *mut pm_node,
    /** OrNode#right

 Represents the right side of the expression.

``` ruby
 left || right
         ^^^^^
```

``` ruby
 1 or 2
      ^
```
*/
    pub right: *mut pm_node,
    /** OrNode#operator_loc

 The Location of the `or` keyword or the `||` operator.

``` ruby
 left or right
      ^^
```
*/
    pub operator_loc: pm_location_t,
}
/** ParametersNode

 Represents the list of parameters on a method, block, or lambda definition.

``` ruby
 def a(b, c, d)
       ^^^^^^^
 end
```

 Type: ::PM_PARAMETERS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_parameters_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ParametersNode#requireds
*/
    pub requireds: pm_node_list,
    /** ParametersNode#optionals
*/
    pub optionals: pm_node_list,
    /** ParametersNode#rest
*/
    pub rest: *mut pm_node,
    /** ParametersNode#posts
*/
    pub posts: pm_node_list,
    /** ParametersNode#keywords
*/
    pub keywords: pm_node_list,
    /** ParametersNode#keyword_rest
*/
    pub keyword_rest: *mut pm_node,
    /** ParametersNode#block
*/
    pub block: *mut pm_node,
}
/** ParenthesesNode

 Represents a parenthesized expression

``` ruby
 (10 + 34)
 ^^^^^^^^^
```

 Type: ::PM_PARENTHESES_NODE

 Flags (#pm_parentheses_node_flags):
 * ::PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_parentheses_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ParenthesesNode#body
*/
    pub body: *mut pm_node,
    /** ParenthesesNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** ParenthesesNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** PinnedExpressionNode

 Represents the use of the `^` operator for pinning an expression in a pattern matching expression.

``` ruby
 foo in ^(bar)
        ^^^^^^
```

 Type: ::PM_PINNED_EXPRESSION_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_pinned_expression_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** PinnedExpressionNode#expression

 The expression used in the pinned expression

``` ruby
 foo in ^(bar)
          ^^^
```
*/
    pub expression: *mut pm_node,
    /** PinnedExpressionNode#operator_loc

 The Location of the `^` operator

``` ruby
 foo in ^(bar)
        ^
```
*/
    pub operator_loc: pm_location_t,
    /** PinnedExpressionNode#lparen_loc

 The Location of the opening parenthesis.

``` ruby
 foo in ^(bar)
         ^
```
*/
    pub lparen_loc: pm_location_t,
    /** PinnedExpressionNode#rparen_loc

 The Location of the closing parenthesis.

``` ruby
 foo in ^(bar)
             ^
```
*/
    pub rparen_loc: pm_location_t,
}
/** PinnedVariableNode

 Represents the use of the `^` operator for pinning a variable in a pattern matching expression.

``` ruby
 foo in ^bar
        ^^^^
```

 Type: ::PM_PINNED_VARIABLE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_pinned_variable_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** PinnedVariableNode#variable

 The variable used in the pinned expression

``` ruby
 foo in ^bar
         ^^^
```
*/
    pub variable: *mut pm_node,
    /** PinnedVariableNode#operator_loc

 The Location of the `^` operator

``` ruby
 foo in ^bar
        ^
```
*/
    pub operator_loc: pm_location_t,
}
/** PostExecutionNode

 Represents the use of the `END` keyword.

``` ruby
 END { foo }
 ^^^^^^^^^^^
```

 Type: ::PM_POST_EXECUTION_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_post_execution_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** PostExecutionNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** PostExecutionNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** PostExecutionNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** PostExecutionNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** PreExecutionNode

 Represents the use of the `BEGIN` keyword.

``` ruby
 BEGIN { foo }
 ^^^^^^^^^^^^^
```

 Type: ::PM_PRE_EXECUTION_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_pre_execution_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** PreExecutionNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** PreExecutionNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** PreExecutionNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** PreExecutionNode#closing_loc
*/
    pub closing_loc: pm_location_t,
}
/** ProgramNode

 The top level node of any parse tree.

 Type: ::PM_PROGRAM_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_program_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ProgramNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** ProgramNode#statements
*/
    pub statements: *mut pm_statements_node,
}
/** RangeNode

 Represents the use of the `..` or `...` operators.

``` ruby
 1..2
 ^^^^
```

``` ruby
 c if a =~ /left/ ... b =~ /right/
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_RANGE_NODE

 Flags (#pm_range_flags):
 * ::PM_RANGE_FLAGS_EXCLUDE_END

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_range_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** 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).

``` ruby
 1...
 ^
```

``` ruby
 hello...goodbye
 ^^^^^
```
*/
    pub left: *mut pm_node,
    /** 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).

``` ruby
 ..5
   ^
```

``` ruby
 1...foo
     ^^^
```
 If neither right-hand or left-hand side was included, this will be an ErrorRecoveryNode.
*/
    pub right: *mut pm_node,
    /** RangeNode#operator_loc

 The Location of the `..` or `...` operator.
*/
    pub operator_loc: pm_location_t,
}
/** RationalNode

 Represents a rational number literal.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_rational_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RationalNode#numerator

 The numerator of the rational number.

``` ruby
 1.5r # numerator 3
```
*/
    pub numerator: pm_integer_t,
    /** RationalNode#denominator

 The denominator of the rational number.

``` ruby
 1.5r # denominator 2
```
*/
    pub denominator: pm_integer_t,
}
/** RedoNode

 Represents the use of the `redo` keyword.

``` ruby
 redo
 ^^^^
```

 Type: ::PM_REDO_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_redo_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** RegularExpressionNode

 Represents a regular expression literal with no interpolation.

``` ruby
 /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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_regular_expression_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RegularExpressionNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** RegularExpressionNode#content_loc
*/
    pub content_loc: pm_location_t,
    /** RegularExpressionNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** RegularExpressionNode#unescaped
*/
    pub unescaped: pm_string_t,
}
/** RequiredKeywordParameterNode

 Represents a required keyword parameter to a method, block, or lambda definition.

``` ruby
 def a(b: )
       ^^
 end
```

 Type: ::PM_REQUIRED_KEYWORD_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_required_keyword_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RequiredKeywordParameterNode#name
*/
    pub name: pm_constant_id_t,
    /** RequiredKeywordParameterNode#name_loc
*/
    pub name_loc: pm_location_t,
}
/** RequiredParameterNode

 Represents a required parameter to a method, block, or lambda definition.

``` ruby
 def a(b)
       ^
 end
```

 Type: ::PM_REQUIRED_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_required_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RequiredParameterNode#name
*/
    pub name: pm_constant_id_t,
}
/** RescueModifierNode

 Represents an expression modified with a rescue.

``` ruby
 foo rescue nil
 ^^^^^^^^^^^^^^
```

 Type: ::PM_RESCUE_MODIFIER_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_rescue_modifier_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RescueModifierNode#expression
*/
    pub expression: *mut pm_node,
    /** RescueModifierNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** RescueModifierNode#rescue_expression
*/
    pub rescue_expression: *mut pm_node,
}
/** RescueNode

 Represents a rescue statement.

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_rescue_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RescueNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** RescueNode#exceptions
*/
    pub exceptions: pm_node_list,
    /** RescueNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** RescueNode#reference
*/
    pub reference: *mut pm_node,
    /** RescueNode#then_keyword_loc
*/
    pub then_keyword_loc: pm_location_t,
    /** RescueNode#statements
*/
    pub statements: *mut pm_statements_node,
    /** RescueNode#subsequent
*/
    pub subsequent: *mut pm_rescue_node,
}
/** RestParameterNode

 Represents a rest parameter to a method, block, or lambda definition.

``` ruby
 def a(*b)
       ^^
 end
```

 Type: ::PM_REST_PARAMETER_NODE

 Flags (#pm_parameter_flags):
 * ::PM_PARAMETER_FLAGS_REPEATED_PARAMETER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_rest_parameter_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** RestParameterNode#name
*/
    pub name: pm_constant_id_t,
    /** RestParameterNode#name_loc
*/
    pub name_loc: pm_location_t,
    /** RestParameterNode#operator_loc
*/
    pub operator_loc: pm_location_t,
}
/** RetryNode

 Represents the use of the `retry` keyword.

``` ruby
 retry
 ^^^^^
```

 Type: ::PM_RETRY_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_retry_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** ReturnNode

 Represents the use of the `return` keyword.

``` ruby
 return 1
 ^^^^^^^^
```

 Type: ::PM_RETURN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_return_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ReturnNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** ReturnNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
}
/** SelfNode

 Represents the `self` keyword.

``` ruby
 self
 ^^^^
```

 Type: ::PM_SELF_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_self_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** ShareableConstantNode

 This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.

``` ruby
 # 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_shareable_constant_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** ShareableConstantNode#write

 The constant write that should be modified with the shareability state.
*/
    pub write: *mut pm_node,
}
/** SingletonClassNode

 Represents a singleton class declaration involving the `class` keyword.

``` ruby
 class << self end
 ^^^^^^^^^^^^^^^^^
```

 Type: ::PM_SINGLETON_CLASS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_singleton_class_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** SingletonClassNode#locals
*/
    pub locals: pm_constant_id_list_t,
    /** SingletonClassNode#class_keyword_loc
*/
    pub class_keyword_loc: pm_location_t,
    /** SingletonClassNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** SingletonClassNode#expression
*/
    pub expression: *mut pm_node,
    /** SingletonClassNode#body
*/
    pub body: *mut pm_node,
    /** SingletonClassNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
}
/** SourceEncodingNode

 Represents the use of the `__ENCODING__` keyword.

``` ruby
 __ENCODING__
 ^^^^^^^^^^^^
```

 Type: ::PM_SOURCE_ENCODING_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_source_encoding_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** SourceFileNode

 Represents the use of the `__FILE__` keyword.

``` ruby
 __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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_source_file_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** SourceFileNode#filepath

 Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism.parse*` APIs.
*/
    pub filepath: pm_string_t,
}
/** SourceLineNode

 Represents the use of the `__LINE__` keyword.

``` ruby
 __LINE__
 ^^^^^^^^
```

 Type: ::PM_SOURCE_LINE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_source_line_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** SplatNode

 Represents the use of the splat operator.

``` ruby
 [*a]
  ^^
```

 Type: ::PM_SPLAT_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_splat_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** SplatNode#operator_loc
*/
    pub operator_loc: pm_location_t,
    /** SplatNode#expression
*/
    pub expression: *mut pm_node,
}
/** StatementsNode

 Represents a set of statements contained within some scope.

``` ruby
 foo; bar; baz
 ^^^^^^^^^^^^^
```

 Type: ::PM_STATEMENTS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_statements_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** StatementsNode#body
*/
    pub body: pm_node_list,
}
/** StringNode

 Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.

``` ruby
 "foo"
 ^^^^^
```

``` ruby
 %w[foo]
    ^^^
```

``` ruby
 "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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_string_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** StringNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** StringNode#content_loc
*/
    pub content_loc: pm_location_t,
    /** StringNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** StringNode#unescaped
*/
    pub unescaped: pm_string_t,
}
/** SuperNode

 Represents the use of the `super` keyword with parentheses or arguments.

``` ruby
 super()
 ^^^^^^^
```

``` ruby
 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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_super_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** SuperNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** SuperNode#lparen_loc
*/
    pub lparen_loc: pm_location_t,
    /** SuperNode#arguments

 Can be only `nil` when there are empty parentheses, like `super()`.
*/
    pub arguments: *mut pm_arguments_node,
    /** SuperNode#rparen_loc
*/
    pub rparen_loc: pm_location_t,
    /** SuperNode#block
*/
    pub block: *mut pm_node,
}
/** SymbolNode

 Represents a symbol literal or a symbol contained within a `%i` list.

``` ruby
 :foo
 ^^^^
```

``` ruby
 %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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_symbol_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** SymbolNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** SymbolNode#content_loc
*/
    pub content_loc: pm_location_t,
    /** SymbolNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** SymbolNode#unescaped
*/
    pub unescaped: pm_string_t,
}
/** TrueNode

 Represents the use of the literal `true` keyword.

``` ruby
 true
 ^^^^
```

 Type: ::PM_TRUE_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_true_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
}
/** UndefNode

 Represents the use of the `undef` keyword.

``` ruby
 undef :foo, :bar, :baz
 ^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNDEF_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_undef_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** UndefNode#names
*/
    pub names: pm_node_list,
    /** UndefNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
}
/** UnlessNode

 Represents the use of the `unless` keyword, either in the block form or the modifier form.

``` ruby
 bar unless foo
 ^^^^^^^^^^^^^^
```

``` ruby
 unless foo then bar end
 ^^^^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNLESS_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_unless_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** UnlessNode#unless_keyword_loc

 The Location of the `unless` keyword.

``` ruby
 unless cond then bar end
 ^^^^^^
```

``` ruby
 bar unless cond
     ^^^^^^
```
*/
    pub unless_keyword_loc: pm_location_t,
    /** 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).

``` ruby
 unless cond then bar end
        ^^^^
```

``` ruby
 bar unless cond
            ^^^^
```
*/
    pub predicate: *mut pm_node,
    /** UnlessNode#then_keyword_loc

 The Location of the `then` keyword, if present.

``` ruby
 unless cond then bar end
             ^^^^
```
*/
    pub then_keyword_loc: pm_location_t,
    /** UnlessNode#statements

 The body of statements that will executed if the unless condition is
 falsey. Will be `nil` if no body is provided.

``` ruby
 unless cond then bar end
                  ^^^
```
*/
    pub statements: *mut pm_statements_node,
    /** UnlessNode#else_clause

 The else clause of the unless expression, if present.

``` ruby
 unless cond then bar else baz end
                      ^^^^^^^^^^^^
```
*/
    pub else_clause: *mut pm_else_node,
    /** UnlessNode#end_keyword_loc

 The Location of the `end` keyword, if present.

``` ruby
 unless cond then bar end
                      ^^^
```
*/
    pub end_keyword_loc: pm_location_t,
}
/** UntilNode

 Represents the use of the `until` keyword, either in the block form or the modifier form.

``` ruby
 bar until foo
 ^^^^^^^^^^^^^
```

``` ruby
 until foo do bar end
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_UNTIL_NODE

 Flags (#pm_loop_flags):
 * ::PM_LOOP_FLAGS_BEGIN_MODIFIER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_until_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** UntilNode#until_keyword_loc
*/
    pub until_keyword_loc: pm_location_t,
    /** UntilNode#do_keyword_loc
*/
    pub do_keyword_loc: pm_location_t,
    /** UntilNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
    /** UntilNode#predicate
*/
    pub predicate: *mut pm_node,
    /** UntilNode#statements
*/
    pub statements: *mut pm_statements_node,
}
/** WhenNode

 Represents the use of the `when` keyword within a case statement.

``` ruby
 case true
 when true
 ^^^^^^^^^
 end
```

 Type: ::PM_WHEN_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_when_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** WhenNode#when_keyword_loc
*/
    pub when_keyword_loc: pm_location_t,
    /** WhenNode#conditions
*/
    pub conditions: pm_node_list,
    /** WhenNode#then_keyword_loc
*/
    pub then_keyword_loc: pm_location_t,
    /** WhenNode#statements
*/
    pub statements: *mut pm_statements_node,
}
/** WhileNode

 Represents the use of the `while` keyword, either in the block form or the modifier form.

``` ruby
 bar while foo
 ^^^^^^^^^^^^^
```

``` ruby
 while foo do bar end
 ^^^^^^^^^^^^^^^^^^^^
```

 Type: ::PM_WHILE_NODE

 Flags (#pm_loop_flags):
 * ::PM_LOOP_FLAGS_BEGIN_MODIFIER

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_while_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** WhileNode#while_keyword_loc
*/
    pub while_keyword_loc: pm_location_t,
    /** WhileNode#do_keyword_loc
*/
    pub do_keyword_loc: pm_location_t,
    /** WhileNode#end_keyword_loc
*/
    pub end_keyword_loc: pm_location_t,
    /** WhileNode#predicate
*/
    pub predicate: *mut pm_node,
    /** WhileNode#statements
*/
    pub statements: *mut pm_statements_node,
}
/** XStringNode

 Represents an xstring literal with no interpolation.

``` ruby
 `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
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_x_string_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** XStringNode#opening_loc
*/
    pub opening_loc: pm_location_t,
    /** XStringNode#content_loc
*/
    pub content_loc: pm_location_t,
    /** XStringNode#closing_loc
*/
    pub closing_loc: pm_location_t,
    /** XStringNode#unescaped
*/
    pub unescaped: pm_string_t,
}
/** YieldNode

 Represents the use of the `yield` keyword.

``` ruby
 yield 1
 ^^^^^^^
```

 Type: ::PM_YIELD_NODE

 @extends pm_node_t
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_yield_node {
    /** The embedded base node.
*/
    pub base: pm_node_t,
    /** YieldNode#keyword_loc
*/
    pub keyword_loc: pm_location_t,
    /** YieldNode#lparen_loc
*/
    pub lparen_loc: pm_location_t,
    /** YieldNode#arguments
*/
    pub arguments: *mut pm_arguments_node,
    /** YieldNode#rparen_loc
*/
    pub rparen_loc: pm_location_t,
}
/** An opaque pointer to a diagnostic generated during parsing.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_diagnostic_t {
    _unused: [u8; 0],
}
/** An opaque pointer to a comment found while parsing.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_comment_t {
    _unused: [u8; 0],
}
/** A list of offsets of the start of lines in a string. The offsets are assumed
 to be sorted/inserted in ascending order.
*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pm_line_offset_list_t {
    /** The number of offsets in the list.
*/
    pub size: usize,
    /** The capacity of the list that has been allocated.
*/
    pub capacity: usize,
    /** The list of offsets.
*/
    pub offsets: *mut u32,
}
/** A line and column in a string.
*/
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct pm_line_column_t {
    /** The line number.
*/
    pub line: i32,
    /** The column in bytes.
*/
    pub column: u32,
}
/** An opaque pointer to a magic comment found while parsing.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_magic_comment_t {
    _unused: [u8; 0],
}
/** A scope of locals surrounding the code that is being parsed.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_options_scope_t {
    _unused: [u8; 0],
}
/** The options that can be passed to the parser.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_options_t {
    _unused: [u8; 0],
}
/** The parser used to parse Ruby source.
*/
#[repr(C)]
#[derive(Debug)]
pub struct pm_parser_t {
    _unused: [u8; 0],
}
/** The default value for parameters.
*/
pub const PM_OPTIONS_SCOPE_FORWARDING_NONE: u8 = 0;
/** When the scope is forwarding with the * parameter.
*/
pub const PM_OPTIONS_SCOPE_FORWARDING_POSITIONALS: u8 = 1;
/** When the scope is forwarding with the ** parameter.
*/
pub const PM_OPTIONS_SCOPE_FORWARDING_KEYWORDS: u8 = 2;
/** When the scope is forwarding with the & parameter.
*/
pub const PM_OPTIONS_SCOPE_FORWARDING_BLOCK: u8 = 4;
/** When the scope is forwarding with the ... parameter.
*/
pub const PM_OPTIONS_SCOPE_FORWARDING_ALL: u8 = 8;
/** A bit representing whether or not the command line -a option was set. -a
 splits the input line $_ into $F.
*/
pub const PM_OPTIONS_COMMAND_LINE_A: u8 = 1;
/** A bit representing whether or not the command line -e option was set. -e
 allow the user to specify a script to be executed. This is necessary for
 prism to know because certain warnings are not generated when -e is used.
*/
pub const PM_OPTIONS_COMMAND_LINE_E: u8 = 2;
/** A bit representing whether or not the command line -l option was set. -l
 chomps the input line by default.
*/
pub const PM_OPTIONS_COMMAND_LINE_L: u8 = 4;
/** A bit representing whether or not the command line -n option was set. -n
 wraps the script in a while gets loop.
*/
pub const PM_OPTIONS_COMMAND_LINE_N: u8 = 8;
/** A bit representing whether or not the command line -p option was set. -p
 prints the value of $_ at the end of each loop.
*/
pub const PM_OPTIONS_COMMAND_LINE_P: u8 = 16;
/** A bit representing whether or not the command line -x option was set. -x
 searches the input file for a shebang that includes "ruby".
*/
pub const PM_OPTIONS_COMMAND_LINE_X: u8 = 32;
/** Returned if the encoding given to a slice query was invalid.
*/
pub const PM_STRING_QUERY_ERROR: pm_string_query_t = -1;
/** Returned if the result of the slice query is false.
*/
pub const PM_STRING_QUERY_FALSE: pm_string_query_t = 0;
/** Returned if the result of the slice query is true.
*/
pub const PM_STRING_QUERY_TRUE: pm_string_query_t = 1;
#[repr(u32)]
#[non_exhaustive]
/** This enum represents every type of node in the Ruby syntax tree.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** ErrorRecoveryNode
*/
    PM_ERROR_RECOVERY_NODE = 51,
    /** FalseNode
*/
    PM_FALSE_NODE = 52,
    /** FindPatternNode
*/
    PM_FIND_PATTERN_NODE = 53,
    /** FlipFlopNode
*/
    PM_FLIP_FLOP_NODE = 54,
    /** FloatNode
*/
    PM_FLOAT_NODE = 55,
    /** ForNode
*/
    PM_FOR_NODE = 56,
    /** ForwardingArgumentsNode
*/
    PM_FORWARDING_ARGUMENTS_NODE = 57,
    /** ForwardingParameterNode
*/
    PM_FORWARDING_PARAMETER_NODE = 58,
    /** ForwardingSuperNode
*/
    PM_FORWARDING_SUPER_NODE = 59,
    /** GlobalVariableAndWriteNode
*/
    PM_GLOBAL_VARIABLE_AND_WRITE_NODE = 60,
    /** GlobalVariableOperatorWriteNode
*/
    PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE = 61,
    /** GlobalVariableOrWriteNode
*/
    PM_GLOBAL_VARIABLE_OR_WRITE_NODE = 62,
    /** GlobalVariableReadNode
*/
    PM_GLOBAL_VARIABLE_READ_NODE = 63,
    /** GlobalVariableTargetNode
*/
    PM_GLOBAL_VARIABLE_TARGET_NODE = 64,
    /** GlobalVariableWriteNode
*/
    PM_GLOBAL_VARIABLE_WRITE_NODE = 65,
    /** HashNode
*/
    PM_HASH_NODE = 66,
    /** HashPatternNode
*/
    PM_HASH_PATTERN_NODE = 67,
    /** IfNode
*/
    PM_IF_NODE = 68,
    /** ImaginaryNode
*/
    PM_IMAGINARY_NODE = 69,
    /** ImplicitNode
*/
    PM_IMPLICIT_NODE = 70,
    /** ImplicitRestNode
*/
    PM_IMPLICIT_REST_NODE = 71,
    /** InNode
*/
    PM_IN_NODE = 72,
    /** IndexAndWriteNode
*/
    PM_INDEX_AND_WRITE_NODE = 73,
    /** IndexOperatorWriteNode
*/
    PM_INDEX_OPERATOR_WRITE_NODE = 74,
    /** IndexOrWriteNode
*/
    PM_INDEX_OR_WRITE_NODE = 75,
    /** IndexTargetNode
*/
    PM_INDEX_TARGET_NODE = 76,
    /** InstanceVariableAndWriteNode
*/
    PM_INSTANCE_VARIABLE_AND_WRITE_NODE = 77,
    /** InstanceVariableOperatorWriteNode
*/
    PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE = 78,
    /** InstanceVariableOrWriteNode
*/
    PM_INSTANCE_VARIABLE_OR_WRITE_NODE = 79,
    /** InstanceVariableReadNode
*/
    PM_INSTANCE_VARIABLE_READ_NODE = 80,
    /** InstanceVariableTargetNode
*/
    PM_INSTANCE_VARIABLE_TARGET_NODE = 81,
    /** InstanceVariableWriteNode
*/
    PM_INSTANCE_VARIABLE_WRITE_NODE = 82,
    /** IntegerNode
*/
    PM_INTEGER_NODE = 83,
    /** InterpolatedMatchLastLineNode
*/
    PM_INTERPOLATED_MATCH_LAST_LINE_NODE = 84,
    /** InterpolatedRegularExpressionNode
*/
    PM_INTERPOLATED_REGULAR_EXPRESSION_NODE = 85,
    /** InterpolatedStringNode
*/
    PM_INTERPOLATED_STRING_NODE = 86,
    /** InterpolatedSymbolNode
*/
    PM_INTERPOLATED_SYMBOL_NODE = 87,
    /** InterpolatedXStringNode
*/
    PM_INTERPOLATED_X_STRING_NODE = 88,
    /** ItLocalVariableReadNode
*/
    PM_IT_LOCAL_VARIABLE_READ_NODE = 89,
    /** ItParametersNode
*/
    PM_IT_PARAMETERS_NODE = 90,
    /** KeywordHashNode
*/
    PM_KEYWORD_HASH_NODE = 91,
    /** KeywordRestParameterNode
*/
    PM_KEYWORD_REST_PARAMETER_NODE = 92,
    /** LambdaNode
*/
    PM_LAMBDA_NODE = 93,
    /** LocalVariableAndWriteNode
*/
    PM_LOCAL_VARIABLE_AND_WRITE_NODE = 94,
    /** LocalVariableOperatorWriteNode
*/
    PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE = 95,
    /** LocalVariableOrWriteNode
*/
    PM_LOCAL_VARIABLE_OR_WRITE_NODE = 96,
    /** LocalVariableReadNode
*/
    PM_LOCAL_VARIABLE_READ_NODE = 97,
    /** LocalVariableTargetNode
*/
    PM_LOCAL_VARIABLE_TARGET_NODE = 98,
    /** LocalVariableWriteNode
*/
    PM_LOCAL_VARIABLE_WRITE_NODE = 99,
    /** MatchLastLineNode
*/
    PM_MATCH_LAST_LINE_NODE = 100,
    /** MatchPredicateNode
*/
    PM_MATCH_PREDICATE_NODE = 101,
    /** MatchRequiredNode
*/
    PM_MATCH_REQUIRED_NODE = 102,
    /** MatchWriteNode
*/
    PM_MATCH_WRITE_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,
    /** NoBlockParameterNode
*/
    PM_NO_BLOCK_PARAMETER_NODE = 109,
    /** NoKeywordsParameterNode
*/
    PM_NO_KEYWORDS_PARAMETER_NODE = 110,
    /** NumberedParametersNode
*/
    PM_NUMBERED_PARAMETERS_NODE = 111,
    /** NumberedReferenceReadNode
*/
    PM_NUMBERED_REFERENCE_READ_NODE = 112,
    /** OptionalKeywordParameterNode
*/
    PM_OPTIONAL_KEYWORD_PARAMETER_NODE = 113,
    /** OptionalParameterNode
*/
    PM_OPTIONAL_PARAMETER_NODE = 114,
    /** OrNode
*/
    PM_OR_NODE = 115,
    /** ParametersNode
*/
    PM_PARAMETERS_NODE = 116,
    /** ParenthesesNode
*/
    PM_PARENTHESES_NODE = 117,
    /** PinnedExpressionNode
*/
    PM_PINNED_EXPRESSION_NODE = 118,
    /** PinnedVariableNode
*/
    PM_PINNED_VARIABLE_NODE = 119,
    /** PostExecutionNode
*/
    PM_POST_EXECUTION_NODE = 120,
    /** PreExecutionNode
*/
    PM_PRE_EXECUTION_NODE = 121,
    /** ProgramNode
*/
    PM_PROGRAM_NODE = 122,
    /** RangeNode
*/
    PM_RANGE_NODE = 123,
    /** RationalNode
*/
    PM_RATIONAL_NODE = 124,
    /** RedoNode
*/
    PM_REDO_NODE = 125,
    /** RegularExpressionNode
*/
    PM_REGULAR_EXPRESSION_NODE = 126,
    /** RequiredKeywordParameterNode
*/
    PM_REQUIRED_KEYWORD_PARAMETER_NODE = 127,
    /** RequiredParameterNode
*/
    PM_REQUIRED_PARAMETER_NODE = 128,
    /** RescueModifierNode
*/
    PM_RESCUE_MODIFIER_NODE = 129,
    /** RescueNode
*/
    PM_RESCUE_NODE = 130,
    /** RestParameterNode
*/
    PM_REST_PARAMETER_NODE = 131,
    /** RetryNode
*/
    PM_RETRY_NODE = 132,
    /** ReturnNode
*/
    PM_RETURN_NODE = 133,
    /** SelfNode
*/
    PM_SELF_NODE = 134,
    /** ShareableConstantNode
*/
    PM_SHAREABLE_CONSTANT_NODE = 135,
    /** SingletonClassNode
*/
    PM_SINGLETON_CLASS_NODE = 136,
    /** SourceEncodingNode
*/
    PM_SOURCE_ENCODING_NODE = 137,
    /** SourceFileNode
*/
    PM_SOURCE_FILE_NODE = 138,
    /** SourceLineNode
*/
    PM_SOURCE_LINE_NODE = 139,
    /** SplatNode
*/
    PM_SPLAT_NODE = 140,
    /** StatementsNode
*/
    PM_STATEMENTS_NODE = 141,
    /** StringNode
*/
    PM_STRING_NODE = 142,
    /** SuperNode
*/
    PM_SUPER_NODE = 143,
    /** SymbolNode
*/
    PM_SYMBOL_NODE = 144,
    /** TrueNode
*/
    PM_TRUE_NODE = 145,
    /** UndefNode
*/
    PM_UNDEF_NODE = 146,
    /** UnlessNode
*/
    PM_UNLESS_NODE = 147,
    /** UntilNode
*/
    PM_UNTIL_NODE = 148,
    /** WhenNode
*/
    PM_WHEN_NODE = 149,
    /** WhileNode
*/
    PM_WHILE_NODE = 150,
    /** XStringNode
*/
    PM_X_STRING_NODE = 151,
    /** YieldNode
*/
    PM_YIELD_NODE = 152,
    /** A special kind of node used for compilation.
*/
    PM_SCOPE_NODE = 153,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for arguments nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** if the arguments contain multiple splats
*/
    PM_ARGUMENTS_NODE_FLAGS_LAST = 65,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for array nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_array_node_flags {
    /** if array contains splat nodes
*/
    PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT = 4,
    /** if array contains splat nodes
*/
    PM_ARRAY_NODE_FLAGS_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for call nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** a call that ignores method visibility
*/
    PM_CALL_NODE_FLAGS_LAST = 33,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for nodes that have unescaped content.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** internal bytes forced the encoding to binary
*/
    PM_ENCODING_FLAGS_LAST = 9,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for integer nodes that correspond to the base of the integer.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** 0x prefix
*/
    PM_INTEGER_BASE_FLAGS_LAST = 33,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** 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_LAST = 9,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for keyword hash nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** 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_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for while and until loop nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** a loop after a begin statement, so the body is executed first before the condition
*/
    PM_LOOP_FLAGS_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for parameter nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_parameter_flags {
    /** a parameter name that has been repeated in the method signature
*/
    PM_PARAMETER_FLAGS_REPEATED_PARAMETER = 4,
    /** a parameter name that has been repeated in the method signature
*/
    PM_PARAMETER_FLAGS_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for parentheses nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_parentheses_node_flags {
    /** parentheses that contain multiple potentially void statements
*/
    PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS = 4,
    /** parentheses that contain multiple potentially void statements
*/
    PM_PARENTHESES_NODE_FLAGS_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for range and flip-flop nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_range_flags {
    /** ... operator
*/
    PM_RANGE_FLAGS_EXCLUDE_END = 4,
    /** ... operator
*/
    PM_RANGE_FLAGS_LAST = 5,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for regular expression and match last line nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** internal bytes forced the encoding to US-ASCII
*/
    PM_REGULAR_EXPRESSION_FLAGS_LAST = 4097,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for shareable constant nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** constant writes that should be modified with shareable constant value experimental copy
*/
    PM_SHAREABLE_CONSTANT_NODE_FLAGS_LAST = 17,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for string nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`
*/
    PM_STRING_FLAGS_LAST = 33,
}
#[repr(u32)]
#[non_exhaustive]
/** Flags for symbol nodes.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub 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,
    /** internal bytes forced the encoding to US-ASCII
*/
    PM_SYMBOL_FLAGS_LAST = 17,
}
#[repr(u32)]
#[non_exhaustive]
/** The levels of errors generated during parsing.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_error_level_t {
    /** For errors that should raise a syntax error.
*/
    PM_ERROR_LEVEL_SYNTAX = 0,
    /** For errors that should raise an argument error.
*/
    PM_ERROR_LEVEL_ARGUMENT = 1,
    /** For errors that should raise a load error.
*/
    PM_ERROR_LEVEL_LOAD = 2,
}
#[repr(u32)]
#[non_exhaustive]
/** The levels of warnings generated during parsing.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_warning_level_t {
    /** For warnings which should be emitted if $VERBOSE != nil.
*/
    PM_WARNING_LEVEL_DEFAULT = 0,
    /** For warnings which should be emitted if $VERBOSE == true.
*/
    PM_WARNING_LEVEL_VERBOSE = 1,
}
#[repr(u32)]
#[non_exhaustive]
/** This is the type of a comment that we've found while parsing.
*/
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum pm_comment_type_t {
    PM_COMMENT_INLINE = 0,
    PM_COMMENT_EMBDOC = 1,
}
impl Default for pm_constant_id_list_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_integer_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_string_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_node_list {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_alias_global_variable_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_alias_method_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_alternation_pattern_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_and_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_arguments_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_array_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_array_pattern_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_assoc_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_assoc_splat_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_begin_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_block_argument_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_block_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_block_parameters_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_break_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_call_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_call_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_call_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_call_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_call_target_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_capture_pattern_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_case_match_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_case_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_class_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_class_variable_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_class_variable_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_class_variable_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_class_variable_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_target_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_path_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_constant_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_def_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_defined_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_else_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_embedded_statements_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_embedded_variable_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_ensure_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_error_recovery_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_find_pattern_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_flip_flop_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_for_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_forwarding_super_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_global_variable_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_global_variable_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_global_variable_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_global_variable_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_hash_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_hash_pattern_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_if_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_imaginary_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_implicit_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_in_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_index_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_index_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_index_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_index_target_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_instance_variable_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_instance_variable_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_instance_variable_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_instance_variable_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_integer_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_interpolated_match_last_line_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_interpolated_regular_expression_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_interpolated_string_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_interpolated_symbol_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_interpolated_x_string_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_keyword_hash_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_lambda_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_local_variable_and_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_local_variable_operator_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_local_variable_or_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_local_variable_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_match_last_line_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_match_predicate_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_match_required_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_match_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_module_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_multi_target_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_multi_write_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_next_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_optional_keyword_parameter_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_optional_parameter_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_or_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_parameters_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_parentheses_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_pinned_expression_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_pinned_variable_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_post_execution_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_pre_execution_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_program_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_range_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_rational_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_regular_expression_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_rescue_modifier_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_rescue_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_return_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_shareable_constant_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_singleton_class_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_source_file_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_splat_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_statements_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_string_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_super_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_symbol_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_undef_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_unless_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_until_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_when_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_while_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_x_string_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_yield_node {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
impl Default for pm_line_offset_list_t {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    /** Returns a newly allocated and initialized arena. If the arena cannot be
 allocated, this function aborts the process.

 @returns A pointer to the newly allocated arena. It is the responsibility of
     the caller to free the arena using pm_arena_free when it is no longer
     needed.
*/
    pub fn pm_arena_new() -> *mut pm_arena_t;
    /** Frees both the held memory and the arena itself.

 @param arena The arena to free.
*/
    pub fn pm_arena_free(arena: *mut pm_arena_t);
    /** Return a raw pointer to the start of a constant.

 @param constant The constant to get the start of.
 @returns A raw pointer to the start of the constant.
*/
    pub fn pm_constant_start(constant: *const pm_constant_t) -> *const u8;
    /** Return the length of a constant.

 @param constant The constant to get the length of.
 @returns The length of the constant.
*/
    pub fn pm_constant_length(constant: *const pm_constant_t) -> usize;
    /** Initialize a string that views the given bytes. The bytes are not copied, so
 they must remain valid for as long as the string is in use.

 @param string The string to initialize.
 @param source The start of the bytes.
 @param length The number of bytes.
*/
    pub fn pm_string_init(string: *mut pm_string_t, source: *const u8, length: usize);
    /** Returns the length associated with the string.

 @param string The string to get the length of.
 @returns The length of the string.
*/
    pub fn pm_string_length(string: *const pm_string_t) -> usize;
    /** Returns the start pointer associated with the string.

 @param string The string to get the start pointer of.
 @returns The start pointer of the string.
*/
    pub fn pm_string_source(string: *const pm_string_t) -> *const u8;
    /** Get the type of the given diagnostic.

 @param diagnostic The diagnostic to get the type of.
 @returns The type of the given diagnostic. Note that this is a string
     representation of an internal ID, and is not meant to be relied upon as a
     stable identifier for the diagnostic. We do not guarantee that these will
     not change in the future. This is meant to be used for debugging and
     error reporting purposes, and not for programmatic checks.
*/
    pub fn pm_diagnostic_type(
        diagnostic: *const pm_diagnostic_t,
    ) -> *const ::std::os::raw::c_char;
    /** Get the location of the given diagnostic.

 @param diagnostic The diagnostic to get the location of.
 @returns The location of the given diagnostic.
*/
    pub fn pm_diagnostic_location(diagnostic: *const pm_diagnostic_t) -> pm_location_t;
    /** Get the message of the given diagnostic.

 @param diagnostic The diagnostic to get the message of.
 @returns The message of the given diagnostic.
*/
    pub fn pm_diagnostic_message(
        diagnostic: *const pm_diagnostic_t,
    ) -> *const ::std::os::raw::c_char;
    /** Get the error level associated with the given diagnostic.

 @param diagnostic The diagnostic to get the error level of.
 @returns The error level of the given diagnostic. If the diagnostic was a
     warning, or is in any way not an error, then the return value is
     undefined and should not be relied upon.
*/
    pub fn pm_diagnostic_error_level(
        diagnostic: *const pm_diagnostic_t,
    ) -> pm_error_level_t;
    /** Get the warning level associated with the given diagnostic.

 @param diagnostic The diagnostic to get the warning level of.
 @returns The warning level of the given diagnostic. If the diagnostic was an
     error, or is in any way not a warning, then the return value is
     undefined and should not be relied upon.
*/
    pub fn pm_diagnostic_warning_level(
        diagnostic: *const pm_diagnostic_t,
    ) -> pm_warning_level_t;
    /** Get the diagnostic that follows the given diagnostic among the errors or the
 warnings of the parser that produced it.

 @param diagnostic The diagnostic to get the successor of.
 @returns The next diagnostic of the same kind, or NULL if the given
     diagnostic is the last one.
*/
    pub fn pm_diagnostic_next(
        diagnostic: *const pm_diagnostic_t,
    ) -> *const pm_diagnostic_t;
    /** Returns the location associated with the given comment.

 @param comment the comment whose location we want to get
 @returns the location associated with the given comment
*/
    pub fn pm_comment_location(comment: *const pm_comment_t) -> pm_location_t;
    /** Returns the type associated with the given comment.

 @param comment the comment whose type we want to get
 @returns the type associated with the given comment. This can either be
     PM_COMMENT_INLINE or PM_COMMENT_EMBDOC.
*/
    pub fn pm_comment_type(comment: *const pm_comment_t) -> pm_comment_type_t;
    /** Returns the comment that follows the given comment among the comments
 associated with the parser that found it.

 @param comment the comment whose successor we want to get
 @returns the next comment, or NULL if the given comment is the last one
*/
    pub fn pm_comment_next(comment: *const pm_comment_t) -> *const pm_comment_t;
    /** Returns the line and column of the given offset. If the offset is not in the
 list, the line and column of the closest offset less than the given offset
 are returned.

 @param list The list to search.
 @param cursor The offset to search for.
 @param start_line The line to start counting from.
 @returns The line and column of the given offset.
*/
    pub fn pm_line_offset_list_line_column(
        list: *const pm_line_offset_list_t,
        cursor: u32,
        start_line: i32,
    ) -> pm_line_column_t;
    /** Returns the location of the key associated with the given magic comment.

 @param magic_comment the magic comment whose key location we want to get
 @returns the location of the key associated with the given magic comment
*/
    pub fn pm_magic_comment_key(
        magic_comment: *const pm_magic_comment_t,
    ) -> pm_location_t;
    /** Returns the location of the value associated with the given magic comment.

 @param magic_comment the magic comment whose value location we want to get
 @returns the location of the value associated with the given magic comment
*/
    pub fn pm_magic_comment_value(
        magic_comment: *const pm_magic_comment_t,
    ) -> pm_location_t;
    /** Returns the magic comment that follows the given magic comment among the
 magic comments associated with the parser that found it.

 @param magic_comment the magic comment whose successor we want to get
 @returns the next magic comment, or NULL if the given magic comment is the
     last one
*/
    pub fn pm_magic_comment_next(
        magic_comment: *const pm_magic_comment_t,
    ) -> *const pm_magic_comment_t;
    /** Allocate a new options struct. If the options struct cannot be allocated,
 this function aborts the process.

 @returns A new options struct with default values. It is the responsibility
     of the caller to free this struct using pm_options_free().
*/
    pub fn pm_options_new() -> *mut pm_options_t;
    /** Free both the held memory of the given options struct and the struct itself.

 @param options The options struct to free.
*/
    pub fn pm_options_free(options: *mut pm_options_t);
    /** Set the filepath option on the given options struct.

 @param options The options struct to set the filepath on.
 @param filepath The filepath to set.
*/
    pub fn pm_options_filepath_set(
        options: *mut pm_options_t,
        filepath: *const ::std::os::raw::c_char,
    );
    /** Set the line option on the given options struct.

 @param options The options struct to set the line on.
 @param line The line to set.
*/
    pub fn pm_options_line_set(options: *mut pm_options_t, line: i32);
    /** Set the encoding option on the given options struct.

 @param options The options struct to set the encoding on.
 @param encoding The encoding to set.
*/
    pub fn pm_options_encoding_set(
        options: *mut pm_options_t,
        encoding: *const ::std::os::raw::c_char,
    );
    /** Set the encoding_locked option on the given options struct.

 @param options The options struct to set the encoding_locked value on.
 @param encoding_locked The encoding_locked value to set.
*/
    pub fn pm_options_encoding_locked_set(
        options: *mut pm_options_t,
        encoding_locked: bool,
    );
    /** Set the frozen string literal option on the given options struct.

 @param options The options struct to set the frozen string literal value on.
 @param frozen_string_literal The frozen string literal value to set.
*/
    pub fn pm_options_frozen_string_literal_set(
        options: *mut pm_options_t,
        frozen_string_literal: bool,
    );
    /** Sets the command line option on the given options struct.

 @param options The options struct to set the command line option on.
 @param command_line The command_line value to set.
*/
    pub fn pm_options_command_line_set(options: *mut pm_options_t, command_line: u8);
    /** Set the version option on the given options struct by parsing the given
 string. If the string contains an invalid option, this returns false.
 Otherwise, it returns true.

 @param options The options struct to set the version on.
 @param version The version to set.
 @param length The length of the version string.
 @returns Whether or not the version was parsed successfully.
*/
    pub fn pm_options_version_set(
        options: *mut pm_options_t,
        version: *const ::std::os::raw::c_char,
        length: usize,
    ) -> bool;
    /** Set the main script option on the given options struct.

 @param options The options struct to set the main script value on.
 @param main_script The main script value to set.
*/
    pub fn pm_options_main_script_set(options: *mut pm_options_t, main_script: bool);
    /** Set the partial script option on the given options struct.

 @param options The options struct to set the partial script value on.
 @param partial_script The partial script value to set.
*/
    pub fn pm_options_partial_script_set(
        options: *mut pm_options_t,
        partial_script: bool,
    );
    /** Allocate and zero out the scopes array on the given options struct.

 @param options The options struct to initialize the scopes array on.
 @param scopes_count The number of scopes to allocate.
 @returns Whether or not the scopes array was initialized successfully.
*/
    pub fn pm_options_scopes_init(
        options: *mut pm_options_t,
        scopes_count: usize,
    ) -> bool;
    /** Return a mutable pointer to the scope at the given index within the given
 options.

 @param options The options struct to get the scope from.
 @param index The index of the scope to get.
 @returns A mutable pointer to the scope at the given index.
*/
    pub fn pm_options_scope_mut(
        options: *mut pm_options_t,
        index: usize,
    ) -> *mut pm_options_scope_t;
    /** Create a new options scope struct. This will hold a set of locals that are in
 scope surrounding the code that is being parsed. If the scope was unable to
 allocate its locals, this function will abort the process.

 @param scope The scope struct to initialize.
 @param locals_count The number of locals to allocate.
*/
    pub fn pm_options_scope_init(scope: *mut pm_options_scope_t, locals_count: usize);
    /** Return a mutable pointer to the local at the given index within the given
 scope, for setting the local's name with pm_string_init. The parser copies
 the name when it is created, so its bytes must remain valid until then.

 @param scope The scope struct to get the local from.
 @param index The index of the local to get.
 @returns A mutable pointer to the local at the given index.
*/
    pub fn pm_options_scope_local_mut(
        scope: *mut pm_options_scope_t,
        index: usize,
    ) -> *mut pm_string_t;
    /** Set the forwarding option on the given scope struct.

 @param scope The scope struct to set the forwarding on.
 @param forwarding The forwarding value to set.
*/
    pub fn pm_options_scope_forwarding_set(
        scope: *mut pm_options_scope_t,
        forwarding: u8,
    );
    /** Allocate and initialize a parser with the given start and end pointers.

 @param arena The arena to use for all AST-lifetime allocations. It is caller-
     owned and must outlive the parser.
 @param source The source to parse.
 @param size The size of the source.
 @param options The optional options to use when parsing. These options must
     live for the whole lifetime of this parser.
 @returns The initialized parser. It is the responsibility of the caller to
     free the parser with `pm_parser_free()`.
*/
    pub fn pm_parser_new(
        arena: *mut pm_arena_t,
        source: *const u8,
        size: usize,
        options: *const pm_options_t,
    ) -> *mut pm_parser_t;
    /** Free both the memory held by the given parser and the parser itself.

 @param parser The parser to free.
*/
    pub fn pm_parser_free(parser: *mut pm_parser_t);
    /** Returns the raw pointer to the start of the source that is being parsed.

 @param parser the parser whose start pointer we want to get
 @returns the raw pointer to the start of the source that is being parsed
*/
    pub fn pm_parser_start(parser: *const pm_parser_t) -> *const u8;
    /** Returns the line that the parser was considered to have started on.

 @param parser the parser whose start line we want to get
 @returns the line that the parser was considered to have started on
*/
    pub fn pm_parser_start_line(parser: *const pm_parser_t) -> i32;
    /** Add a constant to the parser's constant pool, for naming a node that was not
 parsed from the source. If the constant is already in the pool, its existing
 id is returned. Otherwise the parser copies the bytes, so they only need to
 remain valid for the duration of the call.

 Adding a constant makes the pool larger, so a cache with one entry per
 constant built beforehand from pm_parser_constants_size and
 pm_parser_constant_at does not cover it. Build such caches after adding any
 constants.

 @param parser the parser whose constant pool we want to add to
 @param start a pointer to the start of the string to add
 @param length the length of the string to add
 @returns the id of the constant
*/
    pub fn pm_parser_constant_insert(
        parser: *mut pm_parser_t,
        start: *const u8,
        length: usize,
    ) -> pm_constant_id_t;
    /** Returns the frozen string literal value of the parser, as determined by the
 frozen_string_literal magic comment or the option set on the parser.

 @param parser the parser whose frozen string literal value we want to get
 @returns -1 if disabled, 0 if unset, 1 if enabled
*/
    pub fn pm_parser_frozen_string_literal(parser: *const pm_parser_t) -> i8;
    /** Returns the line offsets that are associated with the given parser.

 @param parser the parser whose line offsets we want to get
 @returns the line offsets that are associated with the given parser
*/
    pub fn pm_parser_line_offsets(
        parser: *const pm_parser_t,
    ) -> *const pm_line_offset_list_t;
    /** Returns the location of the __DATA__ section that is associated with the
 given parser.

 @param parser the parser whose data location we want to get
 @returns the location of the __DATA__ section that is associated with the
     given parser. If it is unset, then the length will be set to 0.
*/
    pub fn pm_parser_data_loc(parser: *const pm_parser_t) -> *const pm_location_t;
    /** Returns the number of comments associated with the given parser.

 @param parser the parser whose comments we want to get the size of
 @returns the number of comments associated with the given parser
*/
    pub fn pm_parser_comments_size(parser: *const pm_parser_t) -> usize;
    /** Returns the first comment associated with the given parser. Iterate over the
 rest with pm_comment_next, as in:

 ```c
 for (const pm_comment_t *comment = pm_parser_comments_first(parser); comment != NULL; comment = pm_comment_next(comment)) {
     pm_location_t location = pm_comment_location(comment);
 }
 ```

 @param parser the parser whose comments we want to iterate over
 @returns the first comment, or NULL if there are no comments
*/
    pub fn pm_parser_comments_first(parser: *const pm_parser_t) -> *const pm_comment_t;
    /** Returns the number of magic comments associated with the given parser.

 @param parser the parser whose magic comments we want to get the size of
 @returns the number of magic comments associated with the given parser
*/
    pub fn pm_parser_magic_comments_size(parser: *const pm_parser_t) -> usize;
    /** Returns the first magic comment associated with the given parser. Iterate
 over the rest with pm_magic_comment_next.

 @param parser the parser whose magic comments we want to iterate over
 @returns the first magic comment, or NULL if there are no magic comments
*/
    pub fn pm_parser_magic_comments_first(
        parser: *const pm_parser_t,
    ) -> *const pm_magic_comment_t;
    /** Returns the number of errors associated with the given parser.

 @param parser the parser whose errors we want to get the size of
 @returns the number of errors associated with the given parser
*/
    pub fn pm_parser_errors_size(parser: *const pm_parser_t) -> usize;
    /** Returns the number of warnings associated with the given parser.

 @param parser the parser whose warnings we want to get the size of
 @returns the number of warnings associated with the given parser
*/
    pub fn pm_parser_warnings_size(parser: *const pm_parser_t) -> usize;
    /** Returns the first error associated with the given parser. Iterate over the
 rest with pm_diagnostic_next.

 @param parser the parser whose errors we want to iterate over
 @returns the first error, or NULL if there are no errors
*/
    pub fn pm_parser_errors_first(parser: *const pm_parser_t) -> *const pm_diagnostic_t;
    /** Returns the first warning associated with the given parser. Iterate over the
 rest with pm_diagnostic_next.

 @param parser the parser whose warnings we want to iterate over
 @returns the first warning, or NULL if there are no warnings
*/
    pub fn pm_parser_warnings_first(
        parser: *const pm_parser_t,
    ) -> *const pm_diagnostic_t;
    /** Returns the number of constants in the constant pool associated with the
 given parser.

 @param parser the parser whose constant pool constants we want to get the
     size of
 @returns the number of constants in the constant pool associated with the
     given parser
*/
    pub fn pm_parser_constants_size(parser: *const pm_parser_t) -> usize;
    /** Returns the constant at the given index in the constant pool associated with
 the given parser. Together with pm_constant_id_index, this lets a caller
 build a cache with one entry per constant and then find the entry for any
 constant id, as in:

 ```c
 size_t size = pm_parser_constants_size(parser);
 for (size_t index = 0; index < size; index++) {
     cache[index] = convert(pm_parser_constant_at(parser, index));
 }

 value = cache[pm_constant_id_index(constant_id)];
 ```

 For any constant id, pm_parser_constant_at(parser,
 pm_constant_id_index(constant_id)) is pm_parser_constant(parser,
 constant_id).

 @param parser the parser whose constant pool we want to look up from
 @param index the index of the constant, which must be less than
     pm_parser_constants_size(parser)
 @returns a pointer to the constant at the given index
*/
    pub fn pm_parser_constant_at(
        parser: *const pm_parser_t,
        index: usize,
    ) -> *const pm_constant_t;
    /** Returns a pointer to the constant at the given id in the constant pool
 associated with the given parser.

 @param parser the parser whose constant pool we want to look up from
 @param constant_id the id of the constant to look up. Optional constant
     fields on nodes hold 0 when they are absent, which is not a valid id.
 @returns a pointer to the constant at the given id
*/
    pub fn pm_parser_constant(
        parser: *const pm_parser_t,
        constant_id: pm_constant_id_t,
    ) -> *const pm_constant_t;
    /** Initiate the parser with the given parser.

 @param parser The parser to use.
 @returns The AST representing the source.
*/
    pub fn pm_parse(parser: *mut pm_parser_t) -> *mut pm_node_t;
    /** Append a node to the end of a node list. If the list is full, its storage is
 grown by allocating from the given arena, so the arena must live as long as
 the list does. For a list in a parsed tree, that is the arena that was passed
 to pm_parser_new.

 @param arena The arena to allocate the list's storage from.
 @param list The list to append to.
 @param node The node to append.
*/
    pub fn pm_node_list_append(
        arena: *mut pm_arena_t,
        list: *mut pm_node_list_t,
        node: *mut pm_node_t,
    );
    /** Check that the slice is a valid local variable name.

 @param source The source to check.
 @param length The length of the source.
 @param encoding_name The name of the encoding of the source.
 @returns PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
*/
    pub fn pm_string_query_local(
        source: *const u8,
        length: usize,
        encoding_name: *const ::std::os::raw::c_char,
    ) -> pm_string_query_t;
    /** Check that the slice is a valid constant name.

 @param source The source to check.
 @param length The length of the source.
 @param encoding_name The name of the encoding of the source.
 @returns PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
*/
    pub fn pm_string_query_constant(
        source: *const u8,
        length: usize,
        encoding_name: *const ::std::os::raw::c_char,
    ) -> pm_string_query_t;
    /** Check that the slice is a valid method name.

 @param source The source to check.
 @param length The length of the source.
 @param encoding_name The name of the encoding of the source.
 @returns PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
*/
    pub fn pm_string_query_method_name(
        source: *const u8,
        length: usize,
        encoding_name: *const ::std::os::raw::c_char,
    ) -> pm_string_query_t;
    /** Check that the slice is a keyword.

 @param source The source to check.
 @param length The length of the source.
 @param encoding_name The name of the encoding of the source.
 @returns PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
*/
    pub fn pm_string_query_keyword(
        source: *const u8,
        length: usize,
        encoding_name: *const ::std::os::raw::c_char,
    ) -> pm_string_query_t;
    /** The prism version and the serialization format.

 @returns The prism version as a constant string.
*/
    pub fn pm_version() -> *const ::std::os::raw::c_char;
}