rust.dbscheme

// generated by codegen, do not edit

// from ../shared/tree-sitter-extractor/src/generator/prefix.dbscheme
/*- Files and folders -*/

/**
 * The location of an element.
 * The location spans column `startcolumn` of line `startline` to
 * column `endcolumn` of line `endline` in file `file`.
 * For more information, see
 * [Locations](https://codeql.github.com/docs/writing-codeql-queries/providing-locations-in-codeql-queries/).
 */
locations_default(
  unique int id: @location_default,
  int file: @file ref,
  int beginLine: int ref,
  int beginColumn: int ref,
  int endLine: int ref,
  int endColumn: int ref
);

files(
  unique int id: @file,
  string name: string ref
);

folders(
  unique int id: @folder,
  string name: string ref
);

@container = @file | @folder

containerparent(
  int parent: @container ref,
  unique int child: @container ref
);

/*- Empty location -*/

empty_location(
  int location: @location_default ref
);

/*- Source location prefix -*/

/**
 * The source location of the snapshot.
 */
sourceLocationPrefix(string prefix : string ref);

/*- Diagnostic messages -*/

diagnostics(
  unique int id: @diagnostic,
  int severity: int ref,
  string error_tag: string ref,
  string error_message: string ref,
  string full_error_message: string ref,
  int location: @location_default ref
);

/*- Diagnostic messages: severity -*/

case @diagnostic.severity of
  10 = @diagnostic_debug
| 20 = @diagnostic_info
| 30 = @diagnostic_warning
| 40 = @diagnostic_error
;

/*- YAML -*/

#keyset[parent, idx]
yaml (unique int id: @yaml_node,
      int kind: int ref,
      int parent: @yaml_node_parent ref,
      int idx: int ref,
      string tag: string ref,
      string tostring: string ref);

case @yaml_node.kind of
  0 = @yaml_scalar_node
| 1 = @yaml_mapping_node
| 2 = @yaml_sequence_node
| 3 = @yaml_alias_node
;

@yaml_collection_node = @yaml_mapping_node | @yaml_sequence_node;

@yaml_node_parent = @yaml_collection_node | @file;

yaml_anchors (unique int node: @yaml_node ref,
              string anchor: string ref);

yaml_aliases (unique int alias: @yaml_alias_node ref,
              string target: string ref);

yaml_scalars (unique int scalar: @yaml_scalar_node ref,
              int style: int ref,
              string value: string ref);

yaml_errors (unique int id: @yaml_error,
             string message: string ref);

yaml_locations(unique int locatable: @yaml_locatable ref,
             int location: @location_default ref);

@yaml_locatable = @yaml_node | @yaml_error;

/*- Database metadata -*/
databaseMetadata(
  string metadataKey: string ref,
  string value: string ref
);


// from prefix.dbscheme
#keyset[id]
locatable_locations(
  int id: @locatable ref,
  int location: @location_default ref
);


// from schema

@element =
  @extractor_step
| @locatable
| @named_crate
| @unextracted
;

extractor_steps(
  unique int id: @extractor_step,
  string action: string ref,
  int duration_ms: int ref
);

#keyset[id]
extractor_step_files(
  int id: @extractor_step ref,
  int file: @file ref
);

@locatable =
  @ast_node
| @crate
;

named_crates(
  unique int id: @named_crate,
  string name: string ref,
  int crate: @crate ref
);

@unextracted =
  @missing
| @unimplemented
;

@ast_node =
  @abi
| @addressable
| @arg_list
| @asm_dir_spec
| @asm_operand
| @asm_operand_expr
| @asm_option
| @asm_piece
| @asm_reg_spec
| @assoc_item
| @assoc_item_list
| @attr
| @callable
| @closure_binder
| @expr
| @extern_item
| @extern_item_list
| @field_list
| @format_args_arg
| @generic_arg
| @generic_arg_list
| @generic_param
| @generic_param_list
| @item_list
| @label
| @let_else
| @macro_items
| @match_arm
| @match_arm_list
| @match_guard
| @meta
| @name
| @param_base
| @param_list
| @parenthesized_arg_list
| @pat
| @path
| @path_segment
| @rename
| @resolvable
| @ret_type_repr
| @return_type_syntax
| @source_file
| @stmt
| @stmt_list
| @struct_expr_field
| @struct_expr_field_list
| @struct_field
| @struct_pat_field
| @struct_pat_field_list
| @token
| @token_tree
| @tuple_field
| @type_bound
| @type_bound_list
| @type_repr
| @use_bound_generic_arg
| @use_bound_generic_args
| @use_tree
| @use_tree_list
| @variant_list
| @visibility
| @where_clause
| @where_pred
;

crates(
  unique int id: @crate
);

#keyset[id]
crate_names(
  int id: @crate ref,
  string name: string ref
);

#keyset[id]
crate_versions(
  int id: @crate ref,
  string version: string ref
);

#keyset[id, index]
crate_cfg_options(
  int id: @crate ref,
  int index: int ref,
  string cfg_option: string ref
);

#keyset[id, index]
crate_named_dependencies(
  int id: @crate ref,
  int index: int ref,
  int named_dependency: @named_crate ref
);

missings(
  unique int id: @missing
);

unimplementeds(
  unique int id: @unimplemented
);

abis(
  unique int id: @abi
);

#keyset[id]
abi_abi_strings(
  int id: @abi ref,
  string abi_string: string ref
);

@addressable =
  @item
| @variant
;

#keyset[id]
addressable_extended_canonical_paths(
  int id: @addressable ref,
  string extended_canonical_path: string ref
);

#keyset[id]
addressable_crate_origins(
  int id: @addressable ref,
  string crate_origin: string ref
);

arg_lists(
  unique int id: @arg_list
);

#keyset[id, index]
arg_list_args(
  int id: @arg_list ref,
  int index: int ref,
  int arg: @expr ref
);

asm_dir_specs(
  unique int id: @asm_dir_spec
);

@asm_operand =
  @asm_const
| @asm_label
| @asm_reg_operand
| @asm_sym
;

asm_operand_exprs(
  unique int id: @asm_operand_expr
);

#keyset[id]
asm_operand_expr_in_exprs(
  int id: @asm_operand_expr ref,
  int in_expr: @expr ref
);

#keyset[id]
asm_operand_expr_out_exprs(
  int id: @asm_operand_expr ref,
  int out_expr: @expr ref
);

asm_options(
  unique int id: @asm_option
);

#keyset[id]
asm_option_is_raw(
  int id: @asm_option ref
);

@asm_piece =
  @asm_clobber_abi
| @asm_operand_named
| @asm_options_list
;

asm_reg_specs(
  unique int id: @asm_reg_spec
);

#keyset[id]
asm_reg_spec_identifiers(
  int id: @asm_reg_spec ref,
  int identifier: @name_ref ref
);

@assoc_item =
  @const
| @function
| @macro_call
| @type_alias
;

assoc_item_lists(
  unique int id: @assoc_item_list
);

#keyset[id, index]
assoc_item_list_assoc_items(
  int id: @assoc_item_list ref,
  int index: int ref,
  int assoc_item: @assoc_item ref
);

#keyset[id, index]
assoc_item_list_attrs(
  int id: @assoc_item_list ref,
  int index: int ref,
  int attr: @attr ref
);

attrs(
  unique int id: @attr
);

#keyset[id]
attr_meta(
  int id: @attr ref,
  int meta: @meta ref
);

@callable =
  @closure_expr
| @function
;

#keyset[id]
callable_param_lists(
  int id: @callable ref,
  int param_list: @param_list ref
);

#keyset[id, index]
callable_attrs(
  int id: @callable ref,
  int index: int ref,
  int attr: @attr ref
);

closure_binders(
  unique int id: @closure_binder
);

#keyset[id]
closure_binder_generic_param_lists(
  int id: @closure_binder ref,
  int generic_param_list: @generic_param_list ref
);

@expr =
  @array_expr_internal
| @asm_expr
| @await_expr
| @become_expr
| @binary_expr
| @break_expr
| @call_expr_base
| @cast_expr
| @closure_expr
| @continue_expr
| @field_expr
| @format_args_expr
| @if_expr
| @index_expr
| @labelable_expr
| @let_expr
| @literal_expr
| @macro_block_expr
| @macro_expr
| @match_expr
| @offset_of_expr
| @paren_expr
| @path_expr_base
| @prefix_expr
| @range_expr
| @ref_expr
| @return_expr
| @struct_expr
| @try_expr
| @tuple_expr
| @underscore_expr
| @yeet_expr
| @yield_expr
;

@extern_item =
  @function
| @macro_call
| @static
| @type_alias
;

extern_item_lists(
  unique int id: @extern_item_list
);

#keyset[id, index]
extern_item_list_attrs(
  int id: @extern_item_list ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
extern_item_list_extern_items(
  int id: @extern_item_list ref,
  int index: int ref,
  int extern_item: @extern_item ref
);

@field_list =
  @struct_field_list
| @tuple_field_list
;

format_args_args(
  unique int id: @format_args_arg
);

#keyset[id]
format_args_arg_exprs(
  int id: @format_args_arg ref,
  int expr: @expr ref
);

#keyset[id]
format_args_arg_names(
  int id: @format_args_arg ref,
  int name: @name ref
);

@generic_arg =
  @assoc_type_arg
| @const_arg
| @lifetime_arg
| @type_arg
;

generic_arg_lists(
  unique int id: @generic_arg_list
);

#keyset[id, index]
generic_arg_list_generic_args(
  int id: @generic_arg_list ref,
  int index: int ref,
  int generic_arg: @generic_arg ref
);

@generic_param =
  @const_param
| @lifetime_param
| @type_param
;

generic_param_lists(
  unique int id: @generic_param_list
);

#keyset[id, index]
generic_param_list_generic_params(
  int id: @generic_param_list ref,
  int index: int ref,
  int generic_param: @generic_param ref
);

item_lists(
  unique int id: @item_list
);

#keyset[id, index]
item_list_attrs(
  int id: @item_list ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
item_list_items(
  int id: @item_list ref,
  int index: int ref,
  int item: @item ref
);

labels(
  unique int id: @label
);

#keyset[id]
label_lifetimes(
  int id: @label ref,
  int lifetime: @lifetime ref
);

let_elses(
  unique int id: @let_else
);

#keyset[id]
let_else_block_exprs(
  int id: @let_else ref,
  int block_expr: @block_expr ref
);

macro_items(
  unique int id: @macro_items
);

#keyset[id, index]
macro_items_items(
  int id: @macro_items ref,
  int index: int ref,
  int item: @item ref
);

match_arms(
  unique int id: @match_arm
);

#keyset[id, index]
match_arm_attrs(
  int id: @match_arm ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
match_arm_exprs(
  int id: @match_arm ref,
  int expr: @expr ref
);

#keyset[id]
match_arm_guards(
  int id: @match_arm ref,
  int guard: @match_guard ref
);

#keyset[id]
match_arm_pats(
  int id: @match_arm ref,
  int pat: @pat ref
);

match_arm_lists(
  unique int id: @match_arm_list
);

#keyset[id, index]
match_arm_list_arms(
  int id: @match_arm_list ref,
  int index: int ref,
  int arm: @match_arm ref
);

#keyset[id, index]
match_arm_list_attrs(
  int id: @match_arm_list ref,
  int index: int ref,
  int attr: @attr ref
);

match_guards(
  unique int id: @match_guard
);

#keyset[id]
match_guard_conditions(
  int id: @match_guard ref,
  int condition: @expr ref
);

meta(
  unique int id: @meta
);

#keyset[id]
meta_exprs(
  int id: @meta ref,
  int expr: @expr ref
);

#keyset[id]
meta_is_unsafe(
  int id: @meta ref
);

#keyset[id]
meta_paths(
  int id: @meta ref,
  int path: @path ref
);

#keyset[id]
meta_token_trees(
  int id: @meta ref,
  int token_tree: @token_tree ref
);

names(
  unique int id: @name
);

#keyset[id]
name_texts(
  int id: @name ref,
  string text: string ref
);

@param_base =
  @param
| @self_param
;

#keyset[id, index]
param_base_attrs(
  int id: @param_base ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
param_base_type_reprs(
  int id: @param_base ref,
  int type_repr: @type_repr ref
);

param_lists(
  unique int id: @param_list
);

#keyset[id, index]
param_list_params(
  int id: @param_list ref,
  int index: int ref,
  int param: @param ref
);

#keyset[id]
param_list_self_params(
  int id: @param_list ref,
  int self_param: @self_param ref
);

parenthesized_arg_lists(
  unique int id: @parenthesized_arg_list
);

#keyset[id, index]
parenthesized_arg_list_type_args(
  int id: @parenthesized_arg_list ref,
  int index: int ref,
  int type_arg: @type_arg ref
);

@pat =
  @box_pat
| @const_block_pat
| @ident_pat
| @literal_pat
| @macro_pat
| @or_pat
| @paren_pat
| @path_pat
| @range_pat
| @ref_pat
| @rest_pat
| @slice_pat
| @struct_pat
| @tuple_pat
| @tuple_struct_pat
| @wildcard_pat
;

paths(
  unique int id: @path
);

#keyset[id]
path_qualifiers(
  int id: @path ref,
  int qualifier: @path ref
);

#keyset[id]
path_segments_(
  int id: @path ref,
  int segment: @path_segment ref
);

path_segments(
  unique int id: @path_segment
);

#keyset[id]
path_segment_generic_arg_lists(
  int id: @path_segment ref,
  int generic_arg_list: @generic_arg_list ref
);

#keyset[id]
path_segment_identifiers(
  int id: @path_segment ref,
  int identifier: @name_ref ref
);

#keyset[id]
path_segment_parenthesized_arg_lists(
  int id: @path_segment ref,
  int parenthesized_arg_list: @parenthesized_arg_list ref
);

#keyset[id]
path_segment_ret_types(
  int id: @path_segment ref,
  int ret_type: @ret_type_repr ref
);

#keyset[id]
path_segment_return_type_syntaxes(
  int id: @path_segment ref,
  int return_type_syntax: @return_type_syntax ref
);

#keyset[id]
path_segment_type_reprs(
  int id: @path_segment ref,
  int type_repr: @type_repr ref
);

#keyset[id]
path_segment_trait_type_reprs(
  int id: @path_segment ref,
  int trait_type_repr: @path_type_repr ref
);

renames(
  unique int id: @rename
);

#keyset[id]
rename_names(
  int id: @rename ref,
  int name: @name ref
);

@resolvable =
  @method_call_expr
| @path_ast_node
;

#keyset[id]
resolvable_resolved_paths(
  int id: @resolvable ref,
  string resolved_path: string ref
);

#keyset[id]
resolvable_resolved_crate_origins(
  int id: @resolvable ref,
  string resolved_crate_origin: string ref
);

ret_type_reprs(
  unique int id: @ret_type_repr
);

#keyset[id]
ret_type_repr_type_reprs(
  int id: @ret_type_repr ref,
  int type_repr: @type_repr ref
);

return_type_syntaxes(
  unique int id: @return_type_syntax
);

source_files(
  unique int id: @source_file
);

#keyset[id, index]
source_file_attrs(
  int id: @source_file ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
source_file_items(
  int id: @source_file ref,
  int index: int ref,
  int item: @item ref
);

@stmt =
  @expr_stmt
| @item
| @let_stmt
;

stmt_lists(
  unique int id: @stmt_list
);

#keyset[id, index]
stmt_list_attrs(
  int id: @stmt_list ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
stmt_list_statements(
  int id: @stmt_list ref,
  int index: int ref,
  int statement: @stmt ref
);

#keyset[id]
stmt_list_tail_exprs(
  int id: @stmt_list ref,
  int tail_expr: @expr ref
);

struct_expr_fields(
  unique int id: @struct_expr_field
);

#keyset[id, index]
struct_expr_field_attrs(
  int id: @struct_expr_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
struct_expr_field_exprs(
  int id: @struct_expr_field ref,
  int expr: @expr ref
);

#keyset[id]
struct_expr_field_identifiers(
  int id: @struct_expr_field ref,
  int identifier: @name_ref ref
);

struct_expr_field_lists(
  unique int id: @struct_expr_field_list
);

#keyset[id, index]
struct_expr_field_list_attrs(
  int id: @struct_expr_field_list ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
struct_expr_field_list_fields(
  int id: @struct_expr_field_list ref,
  int index: int ref,
  int field: @struct_expr_field ref
);

#keyset[id]
struct_expr_field_list_spreads(
  int id: @struct_expr_field_list ref,
  int spread: @expr ref
);

struct_fields(
  unique int id: @struct_field
);

#keyset[id, index]
struct_field_attrs(
  int id: @struct_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
struct_field_defaults(
  int id: @struct_field ref,
  int default: @expr ref
);

#keyset[id]
struct_field_is_unsafe(
  int id: @struct_field ref
);

#keyset[id]
struct_field_names(
  int id: @struct_field ref,
  int name: @name ref
);

#keyset[id]
struct_field_type_reprs(
  int id: @struct_field ref,
  int type_repr: @type_repr ref
);

#keyset[id]
struct_field_visibilities(
  int id: @struct_field ref,
  int visibility: @visibility ref
);

struct_pat_fields(
  unique int id: @struct_pat_field
);

#keyset[id, index]
struct_pat_field_attrs(
  int id: @struct_pat_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
struct_pat_field_identifiers(
  int id: @struct_pat_field ref,
  int identifier: @name_ref ref
);

#keyset[id]
struct_pat_field_pats(
  int id: @struct_pat_field ref,
  int pat: @pat ref
);

struct_pat_field_lists(
  unique int id: @struct_pat_field_list
);

#keyset[id, index]
struct_pat_field_list_fields(
  int id: @struct_pat_field_list ref,
  int index: int ref,
  int field: @struct_pat_field ref
);

#keyset[id]
struct_pat_field_list_rest_pats(
  int id: @struct_pat_field_list ref,
  int rest_pat: @rest_pat ref
);

@token =
  @comment
;

token_trees(
  unique int id: @token_tree
);

tuple_fields(
  unique int id: @tuple_field
);

#keyset[id, index]
tuple_field_attrs(
  int id: @tuple_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
tuple_field_type_reprs(
  int id: @tuple_field ref,
  int type_repr: @type_repr ref
);

#keyset[id]
tuple_field_visibilities(
  int id: @tuple_field ref,
  int visibility: @visibility ref
);

type_bounds(
  unique int id: @type_bound
);

#keyset[id]
type_bound_is_async(
  int id: @type_bound ref
);

#keyset[id]
type_bound_is_const(
  int id: @type_bound ref
);

#keyset[id]
type_bound_lifetimes(
  int id: @type_bound ref,
  int lifetime: @lifetime ref
);

#keyset[id]
type_bound_type_reprs(
  int id: @type_bound ref,
  int type_repr: @type_repr ref
);

#keyset[id]
type_bound_use_bound_generic_args(
  int id: @type_bound ref,
  int use_bound_generic_args: @use_bound_generic_args ref
);

type_bound_lists(
  unique int id: @type_bound_list
);

#keyset[id, index]
type_bound_list_bounds(
  int id: @type_bound_list ref,
  int index: int ref,
  int bound: @type_bound ref
);

@type_repr =
  @array_type_repr
| @dyn_trait_type_repr
| @fn_ptr_type_repr
| @for_type_repr
| @impl_trait_type_repr
| @infer_type_repr
| @macro_type_repr
| @never_type_repr
| @paren_type_repr
| @path_type_repr
| @ptr_type_repr
| @ref_type_repr
| @slice_type_repr
| @tuple_type_repr
;

@use_bound_generic_arg =
  @lifetime
| @name_ref
;

use_bound_generic_args(
  unique int id: @use_bound_generic_args
);

#keyset[id, index]
use_bound_generic_args_use_bound_generic_args(
  int id: @use_bound_generic_args ref,
  int index: int ref,
  int use_bound_generic_arg: @use_bound_generic_arg ref
);

use_trees(
  unique int id: @use_tree
);

#keyset[id]
use_tree_is_glob(
  int id: @use_tree ref
);

#keyset[id]
use_tree_paths(
  int id: @use_tree ref,
  int path: @path ref
);

#keyset[id]
use_tree_renames(
  int id: @use_tree ref,
  int rename: @rename ref
);

#keyset[id]
use_tree_use_tree_lists(
  int id: @use_tree ref,
  int use_tree_list: @use_tree_list ref
);

use_tree_lists(
  unique int id: @use_tree_list
);

#keyset[id, index]
use_tree_list_use_trees(
  int id: @use_tree_list ref,
  int index: int ref,
  int use_tree: @use_tree ref
);

variant_lists(
  unique int id: @variant_list
);

#keyset[id, index]
variant_list_variants(
  int id: @variant_list ref,
  int index: int ref,
  int variant: @variant ref
);

visibilities(
  unique int id: @visibility
);

#keyset[id]
visibility_paths(
  int id: @visibility ref,
  int path: @path ref
);

where_clauses(
  unique int id: @where_clause
);

#keyset[id, index]
where_clause_predicates(
  int id: @where_clause ref,
  int index: int ref,
  int predicate: @where_pred ref
);

where_preds(
  unique int id: @where_pred
);

#keyset[id]
where_pred_generic_param_lists(
  int id: @where_pred ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
where_pred_lifetimes(
  int id: @where_pred ref,
  int lifetime: @lifetime ref
);

#keyset[id]
where_pred_type_reprs(
  int id: @where_pred ref,
  int type_repr: @type_repr ref
);

#keyset[id]
where_pred_type_bound_lists(
  int id: @where_pred ref,
  int type_bound_list: @type_bound_list ref
);

array_expr_internals(
  unique int id: @array_expr_internal
);

#keyset[id, index]
array_expr_internal_attrs(
  int id: @array_expr_internal ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
array_expr_internal_exprs(
  int id: @array_expr_internal ref,
  int index: int ref,
  int expr: @expr ref
);

#keyset[id]
array_expr_internal_is_semicolon(
  int id: @array_expr_internal ref
);

array_type_reprs(
  unique int id: @array_type_repr
);

#keyset[id]
array_type_repr_const_args(
  int id: @array_type_repr ref,
  int const_arg: @const_arg ref
);

#keyset[id]
array_type_repr_element_type_reprs(
  int id: @array_type_repr ref,
  int element_type_repr: @type_repr ref
);

asm_clobber_abis(
  unique int id: @asm_clobber_abi
);

asm_consts(
  unique int id: @asm_const
);

#keyset[id]
asm_const_exprs(
  int id: @asm_const ref,
  int expr: @expr ref
);

#keyset[id]
asm_const_is_const(
  int id: @asm_const ref
);

asm_exprs(
  unique int id: @asm_expr
);

#keyset[id, index]
asm_expr_asm_pieces(
  int id: @asm_expr ref,
  int index: int ref,
  int asm_piece: @asm_piece ref
);

#keyset[id, index]
asm_expr_attrs(
  int id: @asm_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
asm_expr_templates(
  int id: @asm_expr ref,
  int index: int ref,
  int template: @expr ref
);

asm_labels(
  unique int id: @asm_label
);

#keyset[id]
asm_label_block_exprs(
  int id: @asm_label ref,
  int block_expr: @block_expr ref
);

asm_operand_nameds(
  unique int id: @asm_operand_named
);

#keyset[id]
asm_operand_named_asm_operands(
  int id: @asm_operand_named ref,
  int asm_operand: @asm_operand ref
);

#keyset[id]
asm_operand_named_names(
  int id: @asm_operand_named ref,
  int name: @name ref
);

asm_options_lists(
  unique int id: @asm_options_list
);

#keyset[id, index]
asm_options_list_asm_options(
  int id: @asm_options_list ref,
  int index: int ref,
  int asm_option: @asm_option ref
);

asm_reg_operands(
  unique int id: @asm_reg_operand
);

#keyset[id]
asm_reg_operand_asm_dir_specs(
  int id: @asm_reg_operand ref,
  int asm_dir_spec: @asm_dir_spec ref
);

#keyset[id]
asm_reg_operand_asm_operand_exprs(
  int id: @asm_reg_operand ref,
  int asm_operand_expr: @asm_operand_expr ref
);

#keyset[id]
asm_reg_operand_asm_reg_specs(
  int id: @asm_reg_operand ref,
  int asm_reg_spec: @asm_reg_spec ref
);

asm_syms(
  unique int id: @asm_sym
);

#keyset[id]
asm_sym_paths(
  int id: @asm_sym ref,
  int path: @path ref
);

assoc_type_args(
  unique int id: @assoc_type_arg
);

#keyset[id]
assoc_type_arg_const_args(
  int id: @assoc_type_arg ref,
  int const_arg: @const_arg ref
);

#keyset[id]
assoc_type_arg_generic_arg_lists(
  int id: @assoc_type_arg ref,
  int generic_arg_list: @generic_arg_list ref
);

#keyset[id]
assoc_type_arg_identifiers(
  int id: @assoc_type_arg ref,
  int identifier: @name_ref ref
);

#keyset[id]
assoc_type_arg_param_lists(
  int id: @assoc_type_arg ref,
  int param_list: @param_list ref
);

#keyset[id]
assoc_type_arg_ret_types(
  int id: @assoc_type_arg ref,
  int ret_type: @ret_type_repr ref
);

#keyset[id]
assoc_type_arg_return_type_syntaxes(
  int id: @assoc_type_arg ref,
  int return_type_syntax: @return_type_syntax ref
);

#keyset[id]
assoc_type_arg_type_reprs(
  int id: @assoc_type_arg ref,
  int type_repr: @type_repr ref
);

#keyset[id]
assoc_type_arg_type_bound_lists(
  int id: @assoc_type_arg ref,
  int type_bound_list: @type_bound_list ref
);

await_exprs(
  unique int id: @await_expr
);

#keyset[id, index]
await_expr_attrs(
  int id: @await_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
await_expr_exprs(
  int id: @await_expr ref,
  int expr: @expr ref
);

become_exprs(
  unique int id: @become_expr
);

#keyset[id, index]
become_expr_attrs(
  int id: @become_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
become_expr_exprs(
  int id: @become_expr ref,
  int expr: @expr ref
);

binary_exprs(
  unique int id: @binary_expr
);

#keyset[id, index]
binary_expr_attrs(
  int id: @binary_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
binary_expr_lhs(
  int id: @binary_expr ref,
  int lhs: @expr ref
);

#keyset[id]
binary_expr_operator_names(
  int id: @binary_expr ref,
  string operator_name: string ref
);

#keyset[id]
binary_expr_rhs(
  int id: @binary_expr ref,
  int rhs: @expr ref
);

box_pats(
  unique int id: @box_pat
);

#keyset[id]
box_pat_pats(
  int id: @box_pat ref,
  int pat: @pat ref
);

break_exprs(
  unique int id: @break_expr
);

#keyset[id, index]
break_expr_attrs(
  int id: @break_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
break_expr_exprs(
  int id: @break_expr ref,
  int expr: @expr ref
);

#keyset[id]
break_expr_lifetimes(
  int id: @break_expr ref,
  int lifetime: @lifetime ref
);

@call_expr_base =
  @call_expr
| @method_call_expr
;

#keyset[id]
call_expr_base_arg_lists(
  int id: @call_expr_base ref,
  int arg_list: @arg_list ref
);

#keyset[id, index]
call_expr_base_attrs(
  int id: @call_expr_base ref,
  int index: int ref,
  int attr: @attr ref
);

cast_exprs(
  unique int id: @cast_expr
);

#keyset[id, index]
cast_expr_attrs(
  int id: @cast_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
cast_expr_exprs(
  int id: @cast_expr ref,
  int expr: @expr ref
);

#keyset[id]
cast_expr_type_reprs(
  int id: @cast_expr ref,
  int type_repr: @type_repr ref
);

closure_exprs(
  unique int id: @closure_expr
);

#keyset[id]
closure_expr_bodies(
  int id: @closure_expr ref,
  int body: @expr ref
);

#keyset[id]
closure_expr_closure_binders(
  int id: @closure_expr ref,
  int closure_binder: @closure_binder ref
);

#keyset[id]
closure_expr_is_async(
  int id: @closure_expr ref
);

#keyset[id]
closure_expr_is_const(
  int id: @closure_expr ref
);

#keyset[id]
closure_expr_is_gen(
  int id: @closure_expr ref
);

#keyset[id]
closure_expr_is_move(
  int id: @closure_expr ref
);

#keyset[id]
closure_expr_is_static(
  int id: @closure_expr ref
);

#keyset[id]
closure_expr_ret_types(
  int id: @closure_expr ref,
  int ret_type: @ret_type_repr ref
);

comments(
  unique int id: @comment,
  int parent: @ast_node ref,
  string text: string ref
);

const_args(
  unique int id: @const_arg
);

#keyset[id]
const_arg_exprs(
  int id: @const_arg ref,
  int expr: @expr ref
);

const_block_pats(
  unique int id: @const_block_pat
);

#keyset[id]
const_block_pat_block_exprs(
  int id: @const_block_pat ref,
  int block_expr: @block_expr ref
);

#keyset[id]
const_block_pat_is_const(
  int id: @const_block_pat ref
);

const_params(
  unique int id: @const_param
);

#keyset[id, index]
const_param_attrs(
  int id: @const_param ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
const_param_default_vals(
  int id: @const_param ref,
  int default_val: @const_arg ref
);

#keyset[id]
const_param_is_const(
  int id: @const_param ref
);

#keyset[id]
const_param_names(
  int id: @const_param ref,
  int name: @name ref
);

#keyset[id]
const_param_type_reprs(
  int id: @const_param ref,
  int type_repr: @type_repr ref
);

continue_exprs(
  unique int id: @continue_expr
);

#keyset[id, index]
continue_expr_attrs(
  int id: @continue_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
continue_expr_lifetimes(
  int id: @continue_expr ref,
  int lifetime: @lifetime ref
);

dyn_trait_type_reprs(
  unique int id: @dyn_trait_type_repr
);

#keyset[id]
dyn_trait_type_repr_type_bound_lists(
  int id: @dyn_trait_type_repr ref,
  int type_bound_list: @type_bound_list ref
);

expr_stmts(
  unique int id: @expr_stmt
);

#keyset[id]
expr_stmt_exprs(
  int id: @expr_stmt ref,
  int expr: @expr ref
);

field_exprs(
  unique int id: @field_expr
);

#keyset[id, index]
field_expr_attrs(
  int id: @field_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
field_expr_containers(
  int id: @field_expr ref,
  int container: @expr ref
);

#keyset[id]
field_expr_identifiers(
  int id: @field_expr ref,
  int identifier: @name_ref ref
);

fn_ptr_type_reprs(
  unique int id: @fn_ptr_type_repr
);

#keyset[id]
fn_ptr_type_repr_abis(
  int id: @fn_ptr_type_repr ref,
  int abi: @abi ref
);

#keyset[id]
fn_ptr_type_repr_is_async(
  int id: @fn_ptr_type_repr ref
);

#keyset[id]
fn_ptr_type_repr_is_const(
  int id: @fn_ptr_type_repr ref
);

#keyset[id]
fn_ptr_type_repr_is_unsafe(
  int id: @fn_ptr_type_repr ref
);

#keyset[id]
fn_ptr_type_repr_param_lists(
  int id: @fn_ptr_type_repr ref,
  int param_list: @param_list ref
);

#keyset[id]
fn_ptr_type_repr_ret_types(
  int id: @fn_ptr_type_repr ref,
  int ret_type: @ret_type_repr ref
);

for_type_reprs(
  unique int id: @for_type_repr
);

#keyset[id]
for_type_repr_generic_param_lists(
  int id: @for_type_repr ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
for_type_repr_type_reprs(
  int id: @for_type_repr ref,
  int type_repr: @type_repr ref
);

format_args_exprs(
  unique int id: @format_args_expr
);

#keyset[id, index]
format_args_expr_args(
  int id: @format_args_expr ref,
  int index: int ref,
  int arg: @format_args_arg ref
);

#keyset[id, index]
format_args_expr_attrs(
  int id: @format_args_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
format_args_expr_templates(
  int id: @format_args_expr ref,
  int template: @expr ref
);

ident_pats(
  unique int id: @ident_pat
);

#keyset[id, index]
ident_pat_attrs(
  int id: @ident_pat ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
ident_pat_is_mut(
  int id: @ident_pat ref
);

#keyset[id]
ident_pat_is_ref(
  int id: @ident_pat ref
);

#keyset[id]
ident_pat_names(
  int id: @ident_pat ref,
  int name: @name ref
);

#keyset[id]
ident_pat_pats(
  int id: @ident_pat ref,
  int pat: @pat ref
);

if_exprs(
  unique int id: @if_expr
);

#keyset[id, index]
if_expr_attrs(
  int id: @if_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
if_expr_conditions(
  int id: @if_expr ref,
  int condition: @expr ref
);

#keyset[id]
if_expr_elses(
  int id: @if_expr ref,
  int else: @expr ref
);

#keyset[id]
if_expr_thens(
  int id: @if_expr ref,
  int then: @block_expr ref
);

impl_trait_type_reprs(
  unique int id: @impl_trait_type_repr
);

#keyset[id]
impl_trait_type_repr_type_bound_lists(
  int id: @impl_trait_type_repr ref,
  int type_bound_list: @type_bound_list ref
);

index_exprs(
  unique int id: @index_expr
);

#keyset[id, index]
index_expr_attrs(
  int id: @index_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
index_expr_bases(
  int id: @index_expr ref,
  int base: @expr ref
);

#keyset[id]
index_expr_indices(
  int id: @index_expr ref,
  int index: @expr ref
);

infer_type_reprs(
  unique int id: @infer_type_repr
);

@item =
  @adt
| @const
| @extern_block
| @extern_crate
| @function
| @impl
| @macro_call
| @macro_def
| @macro_rules
| @module
| @static
| @trait
| @trait_alias
| @type_alias
| @use
;

#keyset[id]
item_attribute_macro_expansions(
  int id: @item ref,
  int attribute_macro_expansion: @macro_items ref
);

@labelable_expr =
  @block_expr
| @looping_expr
;

#keyset[id]
labelable_expr_labels(
  int id: @labelable_expr ref,
  int label: @label ref
);

let_exprs(
  unique int id: @let_expr
);

#keyset[id, index]
let_expr_attrs(
  int id: @let_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
let_expr_scrutinees(
  int id: @let_expr ref,
  int scrutinee: @expr ref
);

#keyset[id]
let_expr_pats(
  int id: @let_expr ref,
  int pat: @pat ref
);

let_stmts(
  unique int id: @let_stmt
);

#keyset[id, index]
let_stmt_attrs(
  int id: @let_stmt ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
let_stmt_initializers(
  int id: @let_stmt ref,
  int initializer: @expr ref
);

#keyset[id]
let_stmt_let_elses(
  int id: @let_stmt ref,
  int let_else: @let_else ref
);

#keyset[id]
let_stmt_pats(
  int id: @let_stmt ref,
  int pat: @pat ref
);

#keyset[id]
let_stmt_type_reprs(
  int id: @let_stmt ref,
  int type_repr: @type_repr ref
);

lifetimes(
  unique int id: @lifetime
);

#keyset[id]
lifetime_texts(
  int id: @lifetime ref,
  string text: string ref
);

lifetime_args(
  unique int id: @lifetime_arg
);

#keyset[id]
lifetime_arg_lifetimes(
  int id: @lifetime_arg ref,
  int lifetime: @lifetime ref
);

lifetime_params(
  unique int id: @lifetime_param
);

#keyset[id, index]
lifetime_param_attrs(
  int id: @lifetime_param ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
lifetime_param_lifetimes(
  int id: @lifetime_param ref,
  int lifetime: @lifetime ref
);

#keyset[id]
lifetime_param_type_bound_lists(
  int id: @lifetime_param ref,
  int type_bound_list: @type_bound_list ref
);

literal_exprs(
  unique int id: @literal_expr
);

#keyset[id, index]
literal_expr_attrs(
  int id: @literal_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
literal_expr_text_values(
  int id: @literal_expr ref,
  string text_value: string ref
);

literal_pats(
  unique int id: @literal_pat
);

#keyset[id]
literal_pat_literals(
  int id: @literal_pat ref,
  int literal: @literal_expr ref
);

macro_block_exprs(
  unique int id: @macro_block_expr
);

#keyset[id]
macro_block_expr_tail_exprs(
  int id: @macro_block_expr ref,
  int tail_expr: @expr ref
);

#keyset[id, index]
macro_block_expr_statements(
  int id: @macro_block_expr ref,
  int index: int ref,
  int statement: @stmt ref
);

macro_exprs(
  unique int id: @macro_expr
);

#keyset[id]
macro_expr_macro_calls(
  int id: @macro_expr ref,
  int macro_call: @macro_call ref
);

macro_pats(
  unique int id: @macro_pat
);

#keyset[id]
macro_pat_macro_calls(
  int id: @macro_pat ref,
  int macro_call: @macro_call ref
);

macro_type_reprs(
  unique int id: @macro_type_repr
);

#keyset[id]
macro_type_repr_macro_calls(
  int id: @macro_type_repr ref,
  int macro_call: @macro_call ref
);

match_exprs(
  unique int id: @match_expr
);

#keyset[id, index]
match_expr_attrs(
  int id: @match_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
match_expr_scrutinees(
  int id: @match_expr ref,
  int scrutinee: @expr ref
);

#keyset[id]
match_expr_match_arm_lists(
  int id: @match_expr ref,
  int match_arm_list: @match_arm_list ref
);

name_refs(
  unique int id: @name_ref
);

#keyset[id]
name_ref_texts(
  int id: @name_ref ref,
  string text: string ref
);

never_type_reprs(
  unique int id: @never_type_repr
);

offset_of_exprs(
  unique int id: @offset_of_expr
);

#keyset[id, index]
offset_of_expr_attrs(
  int id: @offset_of_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
offset_of_expr_fields(
  int id: @offset_of_expr ref,
  int index: int ref,
  int field: @name_ref ref
);

#keyset[id]
offset_of_expr_type_reprs(
  int id: @offset_of_expr ref,
  int type_repr: @type_repr ref
);

or_pats(
  unique int id: @or_pat
);

#keyset[id, index]
or_pat_pats(
  int id: @or_pat ref,
  int index: int ref,
  int pat: @pat ref
);

params(
  unique int id: @param
);

#keyset[id]
param_pats(
  int id: @param ref,
  int pat: @pat ref
);

paren_exprs(
  unique int id: @paren_expr
);

#keyset[id, index]
paren_expr_attrs(
  int id: @paren_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
paren_expr_exprs(
  int id: @paren_expr ref,
  int expr: @expr ref
);

paren_pats(
  unique int id: @paren_pat
);

#keyset[id]
paren_pat_pats(
  int id: @paren_pat ref,
  int pat: @pat ref
);

paren_type_reprs(
  unique int id: @paren_type_repr
);

#keyset[id]
paren_type_repr_type_reprs(
  int id: @paren_type_repr ref,
  int type_repr: @type_repr ref
);

@path_ast_node =
  @path_expr
| @path_pat
| @struct_expr
| @struct_pat
| @tuple_struct_pat
;

#keyset[id]
path_ast_node_paths(
  int id: @path_ast_node ref,
  int path: @path ref
);

@path_expr_base =
  @path_expr
;

path_type_reprs(
  unique int id: @path_type_repr
);

#keyset[id]
path_type_repr_paths(
  int id: @path_type_repr ref,
  int path: @path ref
);

prefix_exprs(
  unique int id: @prefix_expr
);

#keyset[id, index]
prefix_expr_attrs(
  int id: @prefix_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
prefix_expr_exprs(
  int id: @prefix_expr ref,
  int expr: @expr ref
);

#keyset[id]
prefix_expr_operator_names(
  int id: @prefix_expr ref,
  string operator_name: string ref
);

ptr_type_reprs(
  unique int id: @ptr_type_repr
);

#keyset[id]
ptr_type_repr_is_const(
  int id: @ptr_type_repr ref
);

#keyset[id]
ptr_type_repr_is_mut(
  int id: @ptr_type_repr ref
);

#keyset[id]
ptr_type_repr_type_reprs(
  int id: @ptr_type_repr ref,
  int type_repr: @type_repr ref
);

range_exprs(
  unique int id: @range_expr
);

#keyset[id, index]
range_expr_attrs(
  int id: @range_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
range_expr_ends(
  int id: @range_expr ref,
  int end: @expr ref
);

#keyset[id]
range_expr_operator_names(
  int id: @range_expr ref,
  string operator_name: string ref
);

#keyset[id]
range_expr_starts(
  int id: @range_expr ref,
  int start: @expr ref
);

range_pats(
  unique int id: @range_pat
);

#keyset[id]
range_pat_ends(
  int id: @range_pat ref,
  int end: @pat ref
);

#keyset[id]
range_pat_operator_names(
  int id: @range_pat ref,
  string operator_name: string ref
);

#keyset[id]
range_pat_starts(
  int id: @range_pat ref,
  int start: @pat ref
);

ref_exprs(
  unique int id: @ref_expr
);

#keyset[id, index]
ref_expr_attrs(
  int id: @ref_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
ref_expr_exprs(
  int id: @ref_expr ref,
  int expr: @expr ref
);

#keyset[id]
ref_expr_is_const(
  int id: @ref_expr ref
);

#keyset[id]
ref_expr_is_mut(
  int id: @ref_expr ref
);

#keyset[id]
ref_expr_is_raw(
  int id: @ref_expr ref
);

ref_pats(
  unique int id: @ref_pat
);

#keyset[id]
ref_pat_is_mut(
  int id: @ref_pat ref
);

#keyset[id]
ref_pat_pats(
  int id: @ref_pat ref,
  int pat: @pat ref
);

ref_type_reprs(
  unique int id: @ref_type_repr
);

#keyset[id]
ref_type_repr_is_mut(
  int id: @ref_type_repr ref
);

#keyset[id]
ref_type_repr_lifetimes(
  int id: @ref_type_repr ref,
  int lifetime: @lifetime ref
);

#keyset[id]
ref_type_repr_type_reprs(
  int id: @ref_type_repr ref,
  int type_repr: @type_repr ref
);

rest_pats(
  unique int id: @rest_pat
);

#keyset[id, index]
rest_pat_attrs(
  int id: @rest_pat ref,
  int index: int ref,
  int attr: @attr ref
);

return_exprs(
  unique int id: @return_expr
);

#keyset[id, index]
return_expr_attrs(
  int id: @return_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
return_expr_exprs(
  int id: @return_expr ref,
  int expr: @expr ref
);

self_params(
  unique int id: @self_param
);

#keyset[id]
self_param_is_ref(
  int id: @self_param ref
);

#keyset[id]
self_param_is_mut(
  int id: @self_param ref
);

#keyset[id]
self_param_lifetimes(
  int id: @self_param ref,
  int lifetime: @lifetime ref
);

#keyset[id]
self_param_names(
  int id: @self_param ref,
  int name: @name ref
);

slice_pats(
  unique int id: @slice_pat
);

#keyset[id, index]
slice_pat_pats(
  int id: @slice_pat ref,
  int index: int ref,
  int pat: @pat ref
);

slice_type_reprs(
  unique int id: @slice_type_repr
);

#keyset[id]
slice_type_repr_type_reprs(
  int id: @slice_type_repr ref,
  int type_repr: @type_repr ref
);

struct_field_lists(
  unique int id: @struct_field_list
);

#keyset[id, index]
struct_field_list_fields(
  int id: @struct_field_list ref,
  int index: int ref,
  int field: @struct_field ref
);

try_exprs(
  unique int id: @try_expr
);

#keyset[id, index]
try_expr_attrs(
  int id: @try_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
try_expr_exprs(
  int id: @try_expr ref,
  int expr: @expr ref
);

tuple_exprs(
  unique int id: @tuple_expr
);

#keyset[id, index]
tuple_expr_attrs(
  int id: @tuple_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
tuple_expr_fields(
  int id: @tuple_expr ref,
  int index: int ref,
  int field: @expr ref
);

tuple_field_lists(
  unique int id: @tuple_field_list
);

#keyset[id, index]
tuple_field_list_fields(
  int id: @tuple_field_list ref,
  int index: int ref,
  int field: @tuple_field ref
);

tuple_pats(
  unique int id: @tuple_pat
);

#keyset[id, index]
tuple_pat_fields(
  int id: @tuple_pat ref,
  int index: int ref,
  int field: @pat ref
);

tuple_type_reprs(
  unique int id: @tuple_type_repr
);

#keyset[id, index]
tuple_type_repr_fields(
  int id: @tuple_type_repr ref,
  int index: int ref,
  int field: @type_repr ref
);

type_args(
  unique int id: @type_arg
);

#keyset[id]
type_arg_type_reprs(
  int id: @type_arg ref,
  int type_repr: @type_repr ref
);

type_params(
  unique int id: @type_param
);

#keyset[id, index]
type_param_attrs(
  int id: @type_param ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
type_param_default_types(
  int id: @type_param ref,
  int default_type: @type_repr ref
);

#keyset[id]
type_param_names(
  int id: @type_param ref,
  int name: @name ref
);

#keyset[id]
type_param_type_bound_lists(
  int id: @type_param ref,
  int type_bound_list: @type_bound_list ref
);

underscore_exprs(
  unique int id: @underscore_expr
);

#keyset[id, index]
underscore_expr_attrs(
  int id: @underscore_expr ref,
  int index: int ref,
  int attr: @attr ref
);

variants(
  unique int id: @variant
);

#keyset[id, index]
variant_attrs(
  int id: @variant ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
variant_discriminants(
  int id: @variant ref,
  int discriminant: @expr ref
);

#keyset[id]
variant_field_lists(
  int id: @variant ref,
  int field_list: @field_list ref
);

#keyset[id]
variant_names(
  int id: @variant ref,
  int name: @name ref
);

#keyset[id]
variant_visibilities(
  int id: @variant ref,
  int visibility: @visibility ref
);

wildcard_pats(
  unique int id: @wildcard_pat
);

yeet_exprs(
  unique int id: @yeet_expr
);

#keyset[id, index]
yeet_expr_attrs(
  int id: @yeet_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
yeet_expr_exprs(
  int id: @yeet_expr ref,
  int expr: @expr ref
);

yield_exprs(
  unique int id: @yield_expr
);

#keyset[id, index]
yield_expr_attrs(
  int id: @yield_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
yield_expr_exprs(
  int id: @yield_expr ref,
  int expr: @expr ref
);

@adt =
  @enum
| @struct
| @union
;

#keyset[id, index]
adt_derive_macro_expansions(
  int id: @adt ref,
  int index: int ref,
  int derive_macro_expansion: @macro_items ref
);

block_exprs(
  unique int id: @block_expr
);

#keyset[id, index]
block_expr_attrs(
  int id: @block_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
block_expr_is_async(
  int id: @block_expr ref
);

#keyset[id]
block_expr_is_const(
  int id: @block_expr ref
);

#keyset[id]
block_expr_is_gen(
  int id: @block_expr ref
);

#keyset[id]
block_expr_is_move(
  int id: @block_expr ref
);

#keyset[id]
block_expr_is_try(
  int id: @block_expr ref
);

#keyset[id]
block_expr_is_unsafe(
  int id: @block_expr ref
);

#keyset[id]
block_expr_stmt_lists(
  int id: @block_expr ref,
  int stmt_list: @stmt_list ref
);

call_exprs(
  unique int id: @call_expr
);

#keyset[id]
call_expr_functions(
  int id: @call_expr ref,
  int function: @expr ref
);

consts(
  unique int id: @const
);

#keyset[id, index]
const_attrs(
  int id: @const ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
const_bodies(
  int id: @const ref,
  int body: @expr ref
);

#keyset[id]
const_generic_param_lists(
  int id: @const ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
const_is_const(
  int id: @const ref
);

#keyset[id]
const_is_default(
  int id: @const ref
);

#keyset[id]
const_names(
  int id: @const ref,
  int name: @name ref
);

#keyset[id]
const_type_reprs(
  int id: @const ref,
  int type_repr: @type_repr ref
);

#keyset[id]
const_visibilities(
  int id: @const ref,
  int visibility: @visibility ref
);

#keyset[id]
const_where_clauses(
  int id: @const ref,
  int where_clause: @where_clause ref
);

#keyset[id]
const_has_implementation(
  int id: @const ref
);

extern_blocks(
  unique int id: @extern_block
);

#keyset[id]
extern_block_abis(
  int id: @extern_block ref,
  int abi: @abi ref
);

#keyset[id, index]
extern_block_attrs(
  int id: @extern_block ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
extern_block_extern_item_lists(
  int id: @extern_block ref,
  int extern_item_list: @extern_item_list ref
);

#keyset[id]
extern_block_is_unsafe(
  int id: @extern_block ref
);

extern_crates(
  unique int id: @extern_crate
);

#keyset[id, index]
extern_crate_attrs(
  int id: @extern_crate ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
extern_crate_identifiers(
  int id: @extern_crate ref,
  int identifier: @name_ref ref
);

#keyset[id]
extern_crate_renames(
  int id: @extern_crate ref,
  int rename: @rename ref
);

#keyset[id]
extern_crate_visibilities(
  int id: @extern_crate ref,
  int visibility: @visibility ref
);

functions(
  unique int id: @function
);

#keyset[id]
function_abis(
  int id: @function ref,
  int abi: @abi ref
);

#keyset[id]
function_bodies(
  int id: @function ref,
  int body: @block_expr ref
);

#keyset[id]
function_generic_param_lists(
  int id: @function ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
function_is_async(
  int id: @function ref
);

#keyset[id]
function_is_const(
  int id: @function ref
);

#keyset[id]
function_is_default(
  int id: @function ref
);

#keyset[id]
function_is_gen(
  int id: @function ref
);

#keyset[id]
function_is_unsafe(
  int id: @function ref
);

#keyset[id]
function_names(
  int id: @function ref,
  int name: @name ref
);

#keyset[id]
function_ret_types(
  int id: @function ref,
  int ret_type: @ret_type_repr ref
);

#keyset[id]
function_visibilities(
  int id: @function ref,
  int visibility: @visibility ref
);

#keyset[id]
function_where_clauses(
  int id: @function ref,
  int where_clause: @where_clause ref
);

#keyset[id]
function_has_implementation(
  int id: @function ref
);

impls(
  unique int id: @impl
);

#keyset[id]
impl_assoc_item_lists(
  int id: @impl ref,
  int assoc_item_list: @assoc_item_list ref
);

#keyset[id, index]
impl_attrs(
  int id: @impl ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
impl_generic_param_lists(
  int id: @impl ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
impl_is_const(
  int id: @impl ref
);

#keyset[id]
impl_is_default(
  int id: @impl ref
);

#keyset[id]
impl_is_unsafe(
  int id: @impl ref
);

#keyset[id]
impl_self_ties(
  int id: @impl ref,
  int self_ty: @type_repr ref
);

#keyset[id]
impl_traits(
  int id: @impl ref,
  int trait: @type_repr ref
);

#keyset[id]
impl_visibilities(
  int id: @impl ref,
  int visibility: @visibility ref
);

#keyset[id]
impl_where_clauses(
  int id: @impl ref,
  int where_clause: @where_clause ref
);

@looping_expr =
  @for_expr
| @loop_expr
| @while_expr
;

#keyset[id]
looping_expr_loop_bodies(
  int id: @looping_expr ref,
  int loop_body: @block_expr ref
);

macro_calls(
  unique int id: @macro_call
);

#keyset[id, index]
macro_call_attrs(
  int id: @macro_call ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
macro_call_paths(
  int id: @macro_call ref,
  int path: @path ref
);

#keyset[id]
macro_call_token_trees(
  int id: @macro_call ref,
  int token_tree: @token_tree ref
);

#keyset[id]
macro_call_macro_call_expansions(
  int id: @macro_call ref,
  int macro_call_expansion: @ast_node ref
);

macro_defs(
  unique int id: @macro_def
);

#keyset[id]
macro_def_args(
  int id: @macro_def ref,
  int args: @token_tree ref
);

#keyset[id, index]
macro_def_attrs(
  int id: @macro_def ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
macro_def_bodies(
  int id: @macro_def ref,
  int body: @token_tree ref
);

#keyset[id]
macro_def_names(
  int id: @macro_def ref,
  int name: @name ref
);

#keyset[id]
macro_def_visibilities(
  int id: @macro_def ref,
  int visibility: @visibility ref
);

macro_rules(
  unique int id: @macro_rules
);

#keyset[id, index]
macro_rules_attrs(
  int id: @macro_rules ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
macro_rules_names(
  int id: @macro_rules ref,
  int name: @name ref
);

#keyset[id]
macro_rules_token_trees(
  int id: @macro_rules ref,
  int token_tree: @token_tree ref
);

#keyset[id]
macro_rules_visibilities(
  int id: @macro_rules ref,
  int visibility: @visibility ref
);

method_call_exprs(
  unique int id: @method_call_expr
);

#keyset[id]
method_call_expr_generic_arg_lists(
  int id: @method_call_expr ref,
  int generic_arg_list: @generic_arg_list ref
);

#keyset[id]
method_call_expr_identifiers(
  int id: @method_call_expr ref,
  int identifier: @name_ref ref
);

#keyset[id]
method_call_expr_receivers(
  int id: @method_call_expr ref,
  int receiver: @expr ref
);

modules(
  unique int id: @module
);

#keyset[id, index]
module_attrs(
  int id: @module ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
module_item_lists(
  int id: @module ref,
  int item_list: @item_list ref
);

#keyset[id]
module_names(
  int id: @module ref,
  int name: @name ref
);

#keyset[id]
module_visibilities(
  int id: @module ref,
  int visibility: @visibility ref
);

path_exprs(
  unique int id: @path_expr
);

#keyset[id, index]
path_expr_attrs(
  int id: @path_expr ref,
  int index: int ref,
  int attr: @attr ref
);

path_pats(
  unique int id: @path_pat
);

statics(
  unique int id: @static
);

#keyset[id, index]
static_attrs(
  int id: @static ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
static_bodies(
  int id: @static ref,
  int body: @expr ref
);

#keyset[id]
static_is_mut(
  int id: @static ref
);

#keyset[id]
static_is_static(
  int id: @static ref
);

#keyset[id]
static_is_unsafe(
  int id: @static ref
);

#keyset[id]
static_names(
  int id: @static ref,
  int name: @name ref
);

#keyset[id]
static_type_reprs(
  int id: @static ref,
  int type_repr: @type_repr ref
);

#keyset[id]
static_visibilities(
  int id: @static ref,
  int visibility: @visibility ref
);

struct_exprs(
  unique int id: @struct_expr
);

#keyset[id]
struct_expr_struct_expr_field_lists(
  int id: @struct_expr ref,
  int struct_expr_field_list: @struct_expr_field_list ref
);

struct_pats(
  unique int id: @struct_pat
);

#keyset[id]
struct_pat_struct_pat_field_lists(
  int id: @struct_pat ref,
  int struct_pat_field_list: @struct_pat_field_list ref
);

traits(
  unique int id: @trait
);

#keyset[id]
trait_assoc_item_lists(
  int id: @trait ref,
  int assoc_item_list: @assoc_item_list ref
);

#keyset[id, index]
trait_attrs(
  int id: @trait ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
trait_generic_param_lists(
  int id: @trait ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
trait_is_auto(
  int id: @trait ref
);

#keyset[id]
trait_is_unsafe(
  int id: @trait ref
);

#keyset[id]
trait_names(
  int id: @trait ref,
  int name: @name ref
);

#keyset[id]
trait_type_bound_lists(
  int id: @trait ref,
  int type_bound_list: @type_bound_list ref
);

#keyset[id]
trait_visibilities(
  int id: @trait ref,
  int visibility: @visibility ref
);

#keyset[id]
trait_where_clauses(
  int id: @trait ref,
  int where_clause: @where_clause ref
);

trait_aliases(
  unique int id: @trait_alias
);

#keyset[id, index]
trait_alias_attrs(
  int id: @trait_alias ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
trait_alias_generic_param_lists(
  int id: @trait_alias ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
trait_alias_names(
  int id: @trait_alias ref,
  int name: @name ref
);

#keyset[id]
trait_alias_type_bound_lists(
  int id: @trait_alias ref,
  int type_bound_list: @type_bound_list ref
);

#keyset[id]
trait_alias_visibilities(
  int id: @trait_alias ref,
  int visibility: @visibility ref
);

#keyset[id]
trait_alias_where_clauses(
  int id: @trait_alias ref,
  int where_clause: @where_clause ref
);

tuple_struct_pats(
  unique int id: @tuple_struct_pat
);

#keyset[id, index]
tuple_struct_pat_fields(
  int id: @tuple_struct_pat ref,
  int index: int ref,
  int field: @pat ref
);

type_aliases(
  unique int id: @type_alias
);

#keyset[id, index]
type_alias_attrs(
  int id: @type_alias ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
type_alias_generic_param_lists(
  int id: @type_alias ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
type_alias_is_default(
  int id: @type_alias ref
);

#keyset[id]
type_alias_names(
  int id: @type_alias ref,
  int name: @name ref
);

#keyset[id]
type_alias_type_reprs(
  int id: @type_alias ref,
  int type_repr: @type_repr ref
);

#keyset[id]
type_alias_type_bound_lists(
  int id: @type_alias ref,
  int type_bound_list: @type_bound_list ref
);

#keyset[id]
type_alias_visibilities(
  int id: @type_alias ref,
  int visibility: @visibility ref
);

#keyset[id]
type_alias_where_clauses(
  int id: @type_alias ref,
  int where_clause: @where_clause ref
);

uses(
  unique int id: @use
);

#keyset[id, index]
use_attrs(
  int id: @use ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
use_use_trees(
  int id: @use ref,
  int use_tree: @use_tree ref
);

#keyset[id]
use_visibilities(
  int id: @use ref,
  int visibility: @visibility ref
);

enums(
  unique int id: @enum
);

#keyset[id, index]
enum_attrs(
  int id: @enum ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
enum_generic_param_lists(
  int id: @enum ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
enum_names(
  int id: @enum ref,
  int name: @name ref
);

#keyset[id]
enum_variant_lists(
  int id: @enum ref,
  int variant_list: @variant_list ref
);

#keyset[id]
enum_visibilities(
  int id: @enum ref,
  int visibility: @visibility ref
);

#keyset[id]
enum_where_clauses(
  int id: @enum ref,
  int where_clause: @where_clause ref
);

for_exprs(
  unique int id: @for_expr
);

#keyset[id, index]
for_expr_attrs(
  int id: @for_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
for_expr_iterables(
  int id: @for_expr ref,
  int iterable: @expr ref
);

#keyset[id]
for_expr_pats(
  int id: @for_expr ref,
  int pat: @pat ref
);

loop_exprs(
  unique int id: @loop_expr
);

#keyset[id, index]
loop_expr_attrs(
  int id: @loop_expr ref,
  int index: int ref,
  int attr: @attr ref
);

structs(
  unique int id: @struct
);

#keyset[id, index]
struct_attrs(
  int id: @struct ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
struct_field_lists_(
  int id: @struct ref,
  int field_list: @field_list ref
);

#keyset[id]
struct_generic_param_lists(
  int id: @struct ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
struct_names(
  int id: @struct ref,
  int name: @name ref
);

#keyset[id]
struct_visibilities(
  int id: @struct ref,
  int visibility: @visibility ref
);

#keyset[id]
struct_where_clauses(
  int id: @struct ref,
  int where_clause: @where_clause ref
);

unions(
  unique int id: @union
);

#keyset[id, index]
union_attrs(
  int id: @union ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
union_generic_param_lists(
  int id: @union ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
union_names(
  int id: @union ref,
  int name: @name ref
);

#keyset[id]
union_struct_field_lists(
  int id: @union ref,
  int struct_field_list: @struct_field_list ref
);

#keyset[id]
union_visibilities(
  int id: @union ref,
  int visibility: @visibility ref
);

#keyset[id]
union_where_clauses(
  int id: @union ref,
  int where_clause: @where_clause ref
);

while_exprs(
  unique int id: @while_expr
);

#keyset[id, index]
while_expr_attrs(
  int id: @while_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
while_expr_conditions(
  int id: @while_expr ref,
  int condition: @expr ref
);