Module rust

Holds if the file identified by relativePath should be treated as though it is external to the target project, even though it is within the source code directory. This is used for testing.

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, ||.

A method declaration. For example rust fn foo(self, x: u32) -> u64 { (x + 1).into() }

The not equal comparison operation, !=.

A prefix arithmetic operation, such as -.

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

A range-from-to expression. For example: rust let x = 10..20;

A range-full expression. For example: rust let x = ..;

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

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

A range-to-inclusive expression. For example: rust let x = ..=10;

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.

A list of arguments in a function or method call.

An argument position in a 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 call.

NOTE: Consider using Call instead, as that excludes call expressions that are instantiations of tuple structs and tuple variants.

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 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; for<T: std::fmt::Debug> |x: T| { println!("{:?}", x); };

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

A constant item declaration.

A constant access.

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 binder, specifying lifetime or type parameters for a closure or a type.

A for loop expression.

A function pointer type with a for modifier.

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 expression with arguments.

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 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.

NOTE: Consider using MethodCall instead, as that also includes calls to methods using call syntax (such as Foo::method(x)), operation syntax (such as x + y), and indexing syntax (such as x[y]).

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.

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, with an optional tail expression at the end that determines the block’s value.

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 }; let n = Foo { a: 1, b: 2 }.b; Foo { a: m, .. } = 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 let tuple = (1, "one"); let n = (2, "two").0; let (a, b) = tuple;

A field in a tuple struct or tuple variant.

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

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

A call expression that instantiates a tuple struct.

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

A tuple type.

A call expression that instantiates a tuple variant.

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.

An item that defines a type. Either a Struct, Enum, or Union.

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