Module MakeCfgNodes::Nodes

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 inline assembly expression. For example: rust unsafe { #[inline(always)] builtin # asm("cmp {0}, {1}", in(reg) a, in(reg) b); }

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

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

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

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

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

A deref pattern, matching the value behind a smart pointer. This is an experimental Rust feature that cannot be written directly in stable Rust; the example below uses rust-analyzer’s canonical builtin#deref syntax for such patterns: rust match x { builtin#deref(y) => y, _ => 0, };

The base class for expressions.

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

A for loop expression.

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

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 expression produced by the built-in include_bytes! macro, embedding the contents of a file as a byte array. For example: rust let data = include_bytes!("data.bin");

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

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

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 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 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 macro expression, representing the invocation of a macro that produces an expression.

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

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

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

An identifier name.

The !null pattern used in a pattern type to denote a non-null value. Pattern types are an experimental, mostly compiler-internal feature (used in the standard library for types such as NonZero and NonNull) and cannot be written directly in stable Rust; the example below uses rust-analyzer’s canonical builtin#pattern_type syntax: rust type NonNull = builtin#pattern_type(*const () is !null);

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

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

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

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

The base class for patterns.

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

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 pattern. For example: rust match x { Foo::Bar => "ok", _ => "fail", }

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

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 rest pattern (..) in a tuple, slice, or struct pattern.

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

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 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 struct pattern. For example: rust match x { Foo { a: 1, b: 2 } => "ok", Foo { .. } => "fail", }

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

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

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