codeql/rust/ql/lib/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;


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


// from schema

@element =
  @locatable
| @unextracted
;

@locatable =
  @ast_node
;

@unextracted =
  @missing
| @unimplemented
;

@ast_node =
  @abi
| @arg_list
| @assoc_item
| @assoc_item_list
| @attr
| @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
| @lifetime
| @match_arm
| @match_arm_list
| @match_guard
| @meta
| @name
| @name_ref
| @param
| @param_list
| @pat
| @path
| @path_segment
| @record_expr_field
| @record_expr_field_list
| @record_field
| @record_pat_field
| @record_pat_field_list
| @rename
| @ret_type
| @return_type_syntax
| @self_param
| @source_file
| @stmt
| @stmt_list
| @token
| @token_tree
| @tuple_field
| @type_bound
| @type_bound_list
| @type_ref
| @use_tree
| @use_tree_list
| @variant
| @variant_list
| @visibility
| @where_clause
| @where_pred
;

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
);

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
);

@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
);

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
| @asm_expr
| @await_expr
| @become_expr
| @binary_expr
| @block_expr
| @break_expr
| @call_expr
| @cast_expr
| @closure_expr
| @continue_expr
| @field_expr
| @for_expr
| @format_args_expr
| @if_expr
| @index_expr
| @let_expr
| @literal_expr
| @loop_expr
| @macro_expr
| @match_expr
| @method_call_expr
| @offset_of_expr
| @paren_expr
| @path_expr
| @prefix_expr
| @range_expr
| @record_expr
| @ref_expr
| @return_expr
| @try_expr
| @tuple_expr
| @underscore_expr
| @while_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 =
  @record_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
);

lifetimes(
  unique int id: @lifetime
);

#keyset[id]
lifetime_texts(
  int id: @lifetime ref,
  string text: string 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_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
);

name_refs(
  unique int id: @name_ref
);

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

params(
  unique int id: @param
);

#keyset[id, index]
param_attrs(
  int id: @param ref,
  int index: int ref,
  int attr: @attr ref
);

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

#keyset[id]
param_ties(
  int id: @param ref,
  int ty: @type_ref 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
);

@pat =
  @box_pat
| @const_block_pat
| @ident_pat
| @literal_pat
| @macro_pat
| @or_pat
| @paren_pat
| @path_pat
| @range_pat
| @record_pat
| @ref_pat
| @rest_pat
| @slice_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_parts(
  int id: @path ref,
  int part: @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_name_refs(
  int id: @path_segment ref,
  int name_ref: @name_ref ref
);

#keyset[id]
path_segment_param_lists(
  int id: @path_segment ref,
  int param_list: @param_list ref
);

#keyset[id]
path_segment_path_types(
  int id: @path_segment ref,
  int path_type: @path_type ref
);

#keyset[id]
path_segment_ret_types(
  int id: @path_segment ref,
  int ret_type: @ret_type 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_ties(
  int id: @path_segment ref,
  int ty: @type_ref ref
);

record_expr_fields(
  unique int id: @record_expr_field
);

#keyset[id, index]
record_expr_field_attrs(
  int id: @record_expr_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
record_expr_field_exprs(
  int id: @record_expr_field ref,
  int expr: @expr ref
);

#keyset[id]
record_expr_field_name_refs(
  int id: @record_expr_field ref,
  int name_ref: @name_ref ref
);

record_expr_field_lists(
  unique int id: @record_expr_field_list
);

#keyset[id, index]
record_expr_field_list_attrs(
  int id: @record_expr_field_list ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
record_expr_field_list_fields(
  int id: @record_expr_field_list ref,
  int index: int ref,
  int field: @record_expr_field ref
);

#keyset[id]
record_expr_field_list_spreads(
  int id: @record_expr_field_list ref,
  int spread: @expr ref
);

record_fields(
  unique int id: @record_field
);

#keyset[id, index]
record_field_attrs(
  int id: @record_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
record_field_names(
  int id: @record_field ref,
  int name: @name ref
);

#keyset[id]
record_field_ties(
  int id: @record_field ref,
  int ty: @type_ref ref
);

#keyset[id]
record_field_visibilities(
  int id: @record_field ref,
  int visibility: @visibility ref
);

record_pat_fields(
  unique int id: @record_pat_field
);

#keyset[id, index]
record_pat_field_attrs(
  int id: @record_pat_field ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
record_pat_field_name_refs(
  int id: @record_pat_field ref,
  int name_ref: @name_ref ref
);

#keyset[id]
record_pat_field_pats(
  int id: @record_pat_field ref,
  int pat: @pat ref
);

record_pat_field_lists(
  unique int id: @record_pat_field_list
);

#keyset[id, index]
record_pat_field_list_fields(
  int id: @record_pat_field_list ref,
  int index: int ref,
  int field: @record_pat_field ref
);

#keyset[id]
record_pat_field_list_rest_pats(
  int id: @record_pat_field_list ref,
  int rest_pat: @rest_pat ref
);

renames(
  unique int id: @rename
);

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

ret_types(
  unique int id: @ret_type
);

#keyset[id]
ret_type_ties(
  int id: @ret_type ref,
  int ty: @type_ref ref
);

return_type_syntaxes(
  unique int id: @return_type_syntax
);

self_params(
  unique int id: @self_param
);

#keyset[id, index]
self_param_attrs(
  int id: @self_param ref,
  int index: int ref,
  int attr: @attr 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
);

#keyset[id]
self_param_ties(
  int id: @self_param ref,
  int ty: @type_ref ref
);

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
);

@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_ties(
  int id: @tuple_field ref,
  int ty: @type_ref 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_generic_param_lists(
  int id: @type_bound ref,
  int generic_param_list: @generic_param_list ref
);

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

#keyset[id]
type_bound_ties(
  int id: @type_bound ref,
  int ty: @type_ref 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_ref =
  @array_type
| @dyn_trait_type
| @fn_ptr_type
| @for_type
| @impl_trait_type
| @infer_type
| @macro_type
| @never_type
| @paren_type
| @path_type
| @ptr_type
| @ref_type
| @slice_type
| @tuple_type
;

use_trees(
  unique int id: @use_tree
);

#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
);

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_exprs(
  int id: @variant ref,
  int expr: @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
);

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_ties(
  int id: @where_pred ref,
  int ty: @type_ref ref
);

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

array_exprs(
  unique int id: @array_expr
);

#keyset[id, index]
array_expr_attrs(
  int id: @array_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id, index]
array_expr_exprs(
  int id: @array_expr ref,
  int index: int ref,
  int expr: @expr ref
);

array_types(
  unique int id: @array_type
);

#keyset[id]
array_type_const_args(
  int id: @array_type ref,
  int const_arg: @const_arg ref
);

#keyset[id]
array_type_ties(
  int id: @array_type ref,
  int ty: @type_ref ref
);

asm_exprs(
  unique int id: @asm_expr
);

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

#keyset[id]
asm_expr_exprs(
  int id: @asm_expr ref,
  int expr: @expr 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_name_refs(
  int id: @assoc_type_arg ref,
  int name_ref: @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 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_ties(
  int id: @assoc_type_arg ref,
  int ty: @type_ref 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
);

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_labels(
  int id: @block_expr ref,
  int label: @label ref
);

#keyset[id]
block_expr_stmt_lists(
  int id: @block_expr ref,
  int stmt_list: @stmt_list 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_exprs(
  unique int id: @call_expr
);

#keyset[id]
call_expr_arg_lists(
  int id: @call_expr ref,
  int arg_list: @arg_list ref
);

#keyset[id, index]
call_expr_attrs(
  int id: @call_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#keyset[id]
call_expr_exprs(
  int id: @call_expr ref,
  int expr: @expr 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_ties(
  int id: @cast_expr ref,
  int ty: @type_ref ref
);

closure_exprs(
  unique int id: @closure_expr
);

#keyset[id, index]
closure_expr_attrs(
  int id: @closure_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#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_param_lists(
  int id: @closure_expr ref,
  int param_list: @param_list ref
);

#keyset[id]
closure_expr_ret_types(
  int id: @closure_expr ref,
  int ret_type: @ret_type 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
);

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_names(
  int id: @const_param ref,
  int name: @name ref
);

#keyset[id]
const_param_ties(
  int id: @const_param ref,
  int ty: @type_ref 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_types(
  unique int id: @dyn_trait_type
);

#keyset[id]
dyn_trait_type_type_bound_lists(
  int id: @dyn_trait_type 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_exprs(
  int id: @field_expr ref,
  int expr: @expr ref
);

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

fn_ptr_types(
  unique int id: @fn_ptr_type
);

#keyset[id]
fn_ptr_type_abis(
  int id: @fn_ptr_type ref,
  int abi: @abi ref
);

#keyset[id]
fn_ptr_type_param_lists(
  int id: @fn_ptr_type ref,
  int param_list: @param_list ref
);

#keyset[id]
fn_ptr_type_ret_types(
  int id: @fn_ptr_type ref,
  int ret_type: @ret_type 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_labels(
  int id: @for_expr ref,
  int label: @label ref
);

#keyset[id]
for_expr_loop_bodies(
  int id: @for_expr ref,
  int loop_body: @block_expr ref
);

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

for_types(
  unique int id: @for_type
);

#keyset[id]
for_type_generic_param_lists(
  int id: @for_type ref,
  int generic_param_list: @generic_param_list ref
);

#keyset[id]
for_type_ties(
  int id: @for_type ref,
  int ty: @type_ref 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_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_types(
  unique int id: @impl_trait_type
);

#keyset[id]
impl_trait_type_type_bound_lists(
  int id: @impl_trait_type 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_types(
  unique int id: @infer_type
);

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

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_exprs(
  int id: @let_expr ref,
  int expr: @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_ties(
  int id: @let_stmt ref,
  int ty: @type_ref 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
);

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
);

#keyset[id]
loop_expr_labels(
  int id: @loop_expr ref,
  int label: @label ref
);

#keyset[id]
loop_expr_loop_bodies(
  int id: @loop_expr ref,
  int loop_body: @block_expr 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_types(
  unique int id: @macro_type
);

#keyset[id]
macro_type_macro_calls(
  int id: @macro_type 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_exprs(
  int id: @match_expr ref,
  int expr: @expr ref
);

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

method_call_exprs(
  unique int id: @method_call_expr
);

#keyset[id]
method_call_expr_arg_lists(
  int id: @method_call_expr ref,
  int arg_list: @arg_list ref
);

#keyset[id, index]
method_call_expr_attrs(
  int id: @method_call_expr ref,
  int index: int ref,
  int attr: @attr ref
);

#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_name_refs(
  int id: @method_call_expr ref,
  int name_ref: @name_ref ref
);

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

never_types(
  unique int id: @never_type
);

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_ties(
  int id: @offset_of_expr ref,
  int ty: @type_ref 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
);

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_types(
  unique int id: @paren_type
);

#keyset[id]
paren_type_ties(
  int id: @paren_type ref,
  int ty: @type_ref 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
);

#keyset[id]
path_expr_paths(
  int id: @path_expr ref,
  int path: @path ref
);

path_pats(
  unique int id: @path_pat
);

#keyset[id]
path_pat_paths(
  int id: @path_pat ref,
  int path: @path ref
);

path_types(
  unique int id: @path_type
);

#keyset[id]
path_type_paths(
  int id: @path_type 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_types(
  unique int id: @ptr_type
);

#keyset[id]
ptr_type_ties(
  int id: @ptr_type ref,
  int ty: @type_ref 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
);

record_exprs(
  unique int id: @record_expr
);

#keyset[id]
record_expr_paths(
  int id: @record_expr ref,
  int path: @path ref
);

#keyset[id]
record_expr_record_expr_field_lists(
  int id: @record_expr ref,
  int record_expr_field_list: @record_expr_field_list ref
);

record_field_lists(
  unique int id: @record_field_list
);

#keyset[id, index]
record_field_list_fields(
  int id: @record_field_list ref,
  int index: int ref,
  int field: @record_field ref
);

record_pats(
  unique int id: @record_pat
);

#keyset[id]
record_pat_paths(
  int id: @record_pat ref,
  int path: @path ref
);

#keyset[id]
record_pat_record_pat_field_lists(
  int id: @record_pat ref,
  int record_pat_field_list: @record_pat_field_list 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
);

ref_pats(
  unique int id: @ref_pat
);

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

ref_types(
  unique int id: @ref_type
);

#keyset[id]
ref_type_lifetimes(
  int id: @ref_type ref,
  int lifetime: @lifetime ref
);

#keyset[id]
ref_type_ties(
  int id: @ref_type ref,
  int ty: @type_ref 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
);

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_types(
  unique int id: @slice_type
);

#keyset[id]
slice_type_ties(
  int id: @slice_type ref,
  int ty: @type_ref 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_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
);

#keyset[id]
tuple_struct_pat_paths(
  int id: @tuple_struct_pat ref,
  int path: @path ref
);

tuple_types(
  unique int id: @tuple_type
);

#keyset[id, index]
tuple_type_fields(
  int id: @tuple_type ref,
  int index: int ref,
  int field: @type_ref ref
);

type_args(
  unique int id: @type_arg
);

#keyset[id]
type_arg_ties(
  int id: @type_arg ref,
  int ty: @type_ref 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_ref 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
);

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
);

#keyset[id]
while_expr_labels(
  int id: @while_expr ref,
  int label: @label ref
);

#keyset[id]
while_expr_loop_bodies(
  int id: @while_expr ref,
  int loop_body: @block_expr 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
);

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_names(
  int id: @const ref,
  int name: @name ref
);

#keyset[id]
const_ties(
  int id: @const ref,
  int ty: @type_ref ref
);

#keyset[id]
const_visibilities(
  int id: @const 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
);

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
);

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_name_refs(
  int id: @extern_crate ref,
  int name_ref: @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, index]
function_attrs(
  int id: @function ref,
  int index: int ref,
  int attr: @attr 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_names(
  int id: @function ref,
  int name: @name ref
);

#keyset[id]
function_param_lists(
  int id: @function ref,
  int param_list: @param_list ref
);

#keyset[id]
function_ret_types(
  int id: @function ref,
  int ret_type: @ret_type 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
);

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_self_ties(
  int id: @impl ref,
  int self_ty: @type_ref ref
);

#keyset[id]
impl_traits(
  int id: @impl ref,
  int trait: @type_ref 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
);

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
);

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
);

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
);

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_names(
  int id: @static ref,
  int name: @name ref
);

#keyset[id]
static_ties(
  int id: @static ref,
  int ty: @type_ref ref
);

#keyset[id]
static_visibilities(
  int id: @static ref,
  int visibility: @visibility 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
);

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_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
);

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_names(
  int id: @type_alias ref,
  int name: @name ref
);

#keyset[id]
type_alias_ties(
  int id: @type_alias ref,
  int ty: @type_ref 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
);

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_record_field_lists(
  int id: @union ref,
  int record_field_list: @record_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
);

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
);