Module rust

An arithmetic operation, such as +, *=, or -.

An arithmetic assignment operation, such as += or *=.

A bitwise assignment operation, such as |= or <<=.

An assignment expression, for example: rust x = y;

An assignment operation, for example: rust x = y; x += y;

An async block expression. For example: rust async { let x = 42; }

A binary arithmetic operation, such as + or *.

A binary bitwise operation, such as & or <<.

A binary logical operation, such as && or ||.

A bitwise operation, such as &, <<, or |=.

A comparison operation, such as ==, <, or >=.

A compound assignment expression, for example: rust x += y;

A dereference expression, the prefix operator *.

An equality comparison operation, == or !=.

The equal comparison operation, ==.

A source file that was extracted.

A file.

The greater than or equal comparison operation, >=.

The greater than comparison operation, >.

The less than or equal comparison operation, <=.

The less than comparison operation, <.

The logical “and” operation, &&.

A logical “not” operation, !.

A logical operation, such as &&, || or !.

The logical “or” operation, ||.

The not equal comparison operation, !=.

A prefix arithmetic operation, such as -.

A relational comparison operation, that is, one of <=, <, >, or >=.

A successfully extracted file, that is, a file that was extracted and contains no extraction errors or warnings.

A unary logical operation, such as !.

An ABI specification for an extern function or block.

Something that can be addressed by a path.

An ADT (Abstract Data Type) definition, such as Struct, Enum, or Union.

A list of arguments in a function or method call.

The base class for array expressions. For example: rust [1, 2, 3]; [1; 10];

An array expression with a list of elements. For example: rust [1, 2, 3];

An array expression with a repeat operand and a repeat length. For example: rust [1; 10];

An array type representation.

A clobbered ABI in an inline assembly block.

A constant operand in an inline assembly block.

An inline assembly direction specifier.

An inline assembly expression. For example: rust unsafe { #[inline(always)] builtin # asm("cmp {0}, {1}", in(reg) a, in(reg) b); }

A label in an inline assembly block.

An operand expression in an inline assembly block.

A named operand in an inline assembly block.

An option in an inline assembly block.

A list of options in an inline assembly block.

A register operand in an inline assembly block.

A register specification in an inline assembly block.

A symbol operand in an inline assembly block.

An associated item in a Trait or Impl.

A list of AssocItem elements, as appearing in a Trait or Impl.

An associated type argument in a path.

An attribute applied to an item.

An await expression. For example: rust async { let x = foo().await; x }

A become expression. For example: rust fn fact_a(n: i32, a: i32) -> i32 { if n == 0 { a } else { become fact_a(n - 1, n * a) } }

A binary operation expression. For example: rust x + y; x && y; x <= y; x = y; x += y;

A block expression. For example: rust { let x = 42; } rust 'label: { let x = 42; x }

A Boolean literal. Either true or false.

A box pattern. For example: rust match x { box Option::Some(y) => y, box Option::None => 0, };

A break expression. For example: rust loop { if not_ready() { break; } } rust let x = 'label: loop { if done() { break 'label 42; } }; rust let x = 'label: { if exit() { break 'label 42; } 0; };

A function call expression. For example: rust foo(42); foo::<u32, u64>(42); foo[0](42); foo(1) = 4;

A function or method call expression. See CallExpr and MethodCallExpr for further details.

A callable. Either a Function or a ClosureExpr.

A type cast expression. For example: rust value as u64;

A [character literal][1]. For example:

A closure binder, specifying lifetime or type parameters for a closure.

A closure expression. For example: rust |x| x + 1; move |x: i32| -> i32 { x + 1 }; async |x: i32, y| x + y; #[coroutine] |x| yield x; #[coroutine] static |x| yield x;

A comment. For example: rust // this is a comment /// This is a doc comment

A constant item declaration.

A constant argument in a generic argument list.

A const block pattern. For example: rust match x { const { 1 + 2 + 3 } => "ok", _ => "fail", };

A constant parameter in a generic parameter list.

A file or folder.

A continue expression. For example: rust loop { if not_ready() { continue; } } rust 'label: loop { if not_ready() { continue 'label; } }

A Crate. For example: rust todo!()

A dynamic trait object type.

An entity representing an empty location.

An enum declaration.

The base class for expressions.

An expression statement. For example: rust start(); finish(); use std::env;

An extern block containing foreign function declarations.

An extern crate declaration.

An item inside an extern block.

A list of items inside an extern block.

A field access expression. For example: rust x.foo

A list of fields in a struct or enum variant.

A [floating-point literal][1]. For example:

A function pointer type.

A folder.

Provides logic related to Folders.

A for loop expression.

A higher-ranked trait bound.

A format element in a formatting template. For example the {} in: rust println!("Hello {}", "world"); or the {value:#width$.precision$} in: rust println!("Value {value:#width$.precision$}");

A FormatArgsArg. For example the "world" in: rust format_args!("Hello, {}!", "world")

A FormatArgsExpr. For example: rust format_args!("no args"); format_args!("{} foo {:?}", 1, 2); format_args!("{b} foo {a:?}", a=1, b=2); let (x, y) = (1, 42); format_args!("{x}, {y}");

An argument in a format element in a formatting template. For example the width, precision, and value in: rust println!("Value {value:#width$.precision$}"); or the 0, 1 and 2 in: rust println!("Value {0:#1$.2$}", value, width, precision);

A function declaration. For example rust fn foo(x: u32) -> u64 {(x + 1).into()} A function declaration within a trait might not have a body: rust trait Trait { fn bar(); }

A generic argument in a generic argument list.

The base class for generic arguments. rust x.foo::<u32, u64>(42);

A generic parameter in a generic parameter list.

A list of generic parameters. For example: rust fn f<A, B>(a: A, b: B) {} // ^^^^^^ type Foo<T1, T2> = (T1, T2); // ^^^^^^^^

A binding pattern. For example: rust match x { Option::Some(y) => y, Option::None => 0, }; rust match x { y@Option::Some(_) => y, Option::None => 0, };

An if expression. For example: rust if x == 42 { println!("that's the answer"); } rust let y = if x > 0 { 1 } else { 0 };

An `impl`` block.

An impl Trait type.

An index expression. For example: rust list[42]; list[42] = 1;

An inferred type (_).

An [integer literal][1]. For example:

An item such as a function, struct, enum, etc.

A list of items in a module or block.

A label. For example: rust 'label: loop { println!("Hello, world (once)!"); break 'label; };

The base class for expressions that can be labeled (LoopExpr, ForExpr, WhileExpr or BlockExpr).

An else block in a let-else statement.

A let expression. For example: rust if let Some(x) = maybe_some { println!("{}", x); }

A let statement. For example: rust let x = 42; let x: i32 = 42; let x: i32; let x; let (x, y) = (1, 2); let Some(x) = std::env::var("FOO") else { return; };

A lifetime annotation.

A lifetime argument in a generic argument list.

A lifetime parameter in a generic parameter list.

A literal expression. For example: rust 42; 42.0; "Hello, world!"; b"Hello, world!"; 'x'; b'x'; r"Hello, world!"; true;

A literal pattern. For example: rust match x { 42 => "ok", _ => "fail", }

A location as given by a file, a start line, a start column, an end line, and an end column.

A loop expression. For example: rust loop { println!("Hello, world (again)!"); }; rust 'label: loop { println!("Hello, world (once)!"); break 'label; }; rust let mut x = 0; loop { if x < 10 { x += 1; } else { break; } };

The base class for expressions that loop (LoopExpr, ForExpr or WhileExpr).

A sequence of statements generated by a MacroCall. For example: rust fn main() { println!("Hello, world!"); // This macro expands into a list of statements }

A macro invocation.

A Rust 2.0 style declarative macro definition.

A macro expression, representing the invocation of a macro that produces an expression.

A sequence of items generated by a macro. For example:

A macro pattern, representing the invocation of a macro that produces a pattern.

A macro definition using the macro_rules! syntax. rust macro_rules! my_macro { () => { println!("This is a macro!"); }; }

A type produced by a macro.

A match arm. For example: rust match x { Option::Some(y) => y, Option::None => 0, }; rust match x { Some(y) if y != 0 => 1 / y, _ => 0, };

A list of arms in a match expression.

A match expression. For example: rust match x { Option::Some(y) => y, Option::None => 0, } rust match x { Some(y) if y != 0 => 1 / y, _ => 0, }

A guard condition in a match arm.

A meta item in an attribute.

A method call expression. For example: rust x.foo(42); x.foo::<u32, u64>(42);

The base class marking errors during parsing or resolution.

A module declaration. For example: rust mod foo; rust mod bar { pub fn baz() {} }

An identifier name.

A reference to a name.

INTERNAL: Do not use.

A named FormatArgument. For example name in rust let name = "Alice"; println!("{name} in wonderland");

The never type !.

A number literal.

An offset_of expression. For example: rust builtin # offset_of(Struct, field);

An operation, for example &&, +=, ! or *.

An or pattern. For example: rust match x { Option::Some(y) | Option::None => 0, }

A parameter in a function or method. For example x in: rust fn new(x: T) -> Foo<T> { // ... }

A normal parameter, Param, or a self parameter SelfParam.

A list of parameters in a function, method, or closure declaration.

A parenthesized expression.

A parenthesized pattern.

A parenthesized type.

A parenthesized argument list as used in function traits.

The base class for patterns.

A path. For example: rust use some_crate::some_module::some_item; foo::bar;

An AST element wrapping a path (PathExpr, RecordExpr, PathPat, RecordPat, TupleStructPat).

A path expression. For example: rust let x = variable; let x = foo::bar; let y = <T>::foo; let z = <TypeRepr as Trait>::foo;

A path expression or a variable access in a formatting template. See PathExpr and FormatTemplateVariableAccess for further details.

A path pattern. For example: rust match x { Foo::Bar => "ok", _ => "fail", }

A path segment, which is one part of a whole path. For example: - HashMap - HashMap<K, V> - Fn(i32) -> i32 - widgets(..) - <T as Iterator>

A path referring to a type. For example: rust type X = std::collections::HashMap<i32, i32>; type Y = X::Item;

A positional FormatArgument. For example 0 in rust let name = "Alice"; println!("{0} in wonderland", name);

A unary operation expression. For example: rust let x = -42; let y = !true; let z = *ptr;

A pointer type.

A range expression. For example: rust let x = 1..=10; let x = 1..10; let x = 10..; let x = ..10; let x = ..=10; let x = ..;

A range pattern. For example: rust match x { ..15 => "too cold", 16..=25 => "just right", 26.. => "too hot", }

A reference expression. For example: rust let ref_const = &foo; let ref_mut = &mut foo; let raw_const: &mut i32 = &raw const foo; let raw_mut: &mut i32 = &raw mut foo;

A reference pattern. For example: rust match x { &mut Option::Some(y) => y, &Option::None => 0, };

A reference type.

A rename in a use declaration.

One of PathExpr, RecordExpr, PathPat, RecordPat, TupleStructPat or MethodCallExpr.

A rest pattern (..) in a tuple, slice, or struct pattern.

A return type in a function signature.

A return expression. For example: rust fn some_value() -> i32 { return 42; } rust fn no_value() -> () { return; }

A return type notation (..) to reference or bound the type returned by a trait method

A self parameter. For example self in: rust struct X; impl X { fn one(&self) {} fn two(&mut self) {} fn three(self) {} fn four(mut self) {} fn five<'a>(&'a self) {} }

A slice pattern. For example: rust match x { [1, 2, 3, 4, 5] => "ok", [1, 2, ..] => "fail", [x, y, .., z, 7] => "fail", }

A slice type.

A source file.

A static item declaration.

The base class for statements.

A list of statements in a block.

A [string literal][1]. For example:

A Struct. For example: rust struct Point { x: i32, y: i32, }

A struct expression. For example: rust let first = Foo { a: 1, b: 2 }; let second = Foo { a: 2, ..first }; Foo { a: 1, b: 2 }[2] = 10; Foo { .. } = second;

A field in a struct expression. For example a: 1 in: rust Foo { a: 1, b: 2 };

A list of fields in a struct expression.

A field in a struct declaration.

A list of fields in a struct declaration.

A struct pattern. For example: rust match x { Foo { a: 1, b: 2 } => "ok", Foo { .. } => "fail", }

A field in a struct pattern. For example a: 1 in: rust let Foo { a: 1, b: 2 } = foo;

A list of fields in a struct pattern.

The base class for all tokens.

A token tree in a macro definition or invocation.

A Trait. For example:

A trait alias.

A try expression using the ? operator.

A tuple expression. For example: rust (1, "one"); (2, "two")[0] = 3;

A field in a tuple struct or tuple enum variant.

A list of fields in a tuple struct or tuple enum variant.

A tuple pattern. For example: rust let (x, y) = (1, 2); let (a, b, .., z) = (1, 2, 3, 4, 5);

A tuple struct pattern. For example: rust match x { Tuple("a", 1, 2, 3) => "great", Tuple(.., 3) => "fine", Tuple(..) => "fail", };

A tuple type.

A type alias. For example:

A type argument in a generic argument list.

A type bound in a trait or generic parameter.

A list of type bounds.

A type parameter in a generic parameter list.

The base class for type references. rust let x: i32; let y: Vec<i32>; let z: Option<i32>;

An underscore expression. For example: rust _ = 42;

The base class marking everything that was not properly extracted for some reason, such as: * syntax errors * insufficient context information * yet unimplemented parts of the extractor

The base class for unimplemented nodes. This is used to mark nodes that are not yet extracted.

A union declaration.

A use statement. For example: rust use std::collections::HashMap;

A use<..> bound to control which generic parameters are captured by an impl Trait return type.

A use tree, that is, the part after the use keyword in a use statement. For example: rust use std::collections::HashMap; use std::collections::*; use std::collections::HashMap as MyHashMap; use std::collections::{self, HashMap, HashSet};

A list of use trees in a use declaration.

A variable.

A variable access.

A variable read.

A variable write.

A variant in an enum declaration.

A list of variants in an enum declaration.

A visibility modifier.

A where clause in a generic declaration.

A predicate in a where clause.

A while loop expression.

A wildcard pattern. For example: rust let _ = 42;

A yeet expression. For example: rust if x < size { do yeet "index out of bounds"; }

A yield expression. For example: rust let one = #[coroutine] || { yield 1; };