The binary interface of a function: extern "C".
Angle bracketed arguments of a path segment: the <K, V> in HashMap<K, V>.
One arm of a match expression: 0...10 => { return true; }.
An attribute like #[repr(transparent)].
An argument in a function type: the usize in fn(usize) -> bool.
A binding (equality constraint) on an associated type: Item = u8.
A braced block containing Rust statements.
A set of bound lifetimes: for<'a, 'b, 'c>.
A const generic parameter: const LENGTH: usize.
An associated type bound: Iterator<Item: Display>.
An enum input to a proc_macro_derive macro.
A struct input to a proc_macro_derive macro.
An untagged union input to a proc_macro_derive macro.
Data structure sent to a proc_macro_derive macro.
Error returned when a Syn parser cannot parse the input tokens.
A slice literal expression: [a, b, c, d].
An assignment expression: a = compute().
A compound assignment expression: counter += 1.
An async block: async { ... }.
An await expression: fut.await.
A binary operation: a + b, a * b.
A blocked scope: { ... }.
A box expression: box f.
A break, with an optional label to break and an optional
expression.
A function call expression: invoke(a, b).
A cast expression: foo as f64.
A closure expression: |a, b| a + b.
A continue, with an optional label.
Access of a named struct field (obj.k) or unnamed tuple struct
field (obj.0).
A for loop: for pat in expr { ... }.
An expression contained within invisible delimiters.
An if expression with an optional else block: if expr { ... } else { ... }.
A square bracketed indexing expression: vector[2].
A let guard: let Some(x) = opt.
A literal in place of an expression: 1, "foo".
Conditionless loop: loop { ... }.
A macro invocation expression: format!("{}", q).
A match expression: match n { Some(n) => {}, None => {} }.
A method call expression: x.foo::<T>(a, b).
A parenthesized expression: (a + b).
A path like std::mem::replace possibly containing generic
parameters and a qualified self-type.
A range expression: 1..2, 1.., ..2, 1..=2, ..=2.
A referencing operation: &a or &mut a.
An array literal constructed from one repeated element: [0u8; N].
A return, with an optional value to be returned.
A struct literal expression: Point { x: 1, y: 1 }.
A try-expression: expr?.
A try block: try { ... }.
A tuple expression: (a, b, c, d).
A type ascription expression: foo: f64.
A unary operation: !x, *x.
An unsafe block: unsafe { ... }.
A while loop: while expr { ... }.
A yield expression: yield expr.
A field of a struct or enum variant.
A single field in a struct pattern.
A field-value pair in a struct literal.
Named fields of a struct or struct variant such as Point { x: f64, y: f64 }.
Unnamed fields of a tuple struct or tuple variant such as Some(T).
A complete file of Rust source code.
A foreign function in an extern block.
A macro invocation within an extern block.
A foreign static item in an extern block: static ext: u8.
A foreign type in an extern block: type void.
Lifetimes and type parameters attached to a declaration of a function,
enum, trait, etc.
A word of Rust code, which may be a keyword or legal variable name.
Returned by Generics::split_for_impl.
An associated constant within an impl block.
A macro invocation within an impl block.
A method within an impl block.
An associated type within an impl block.
The index of an unnamed tuple struct field.
A constant item: const MAX: u16 = 65535.
An enum definition: enum Foo<A, B> { A(A), B(B) }.
An extern crate item: extern crate serde.
A free-standing function: fn process(n: usize) -> Result<()> { ... }.
A block of foreign items: extern "C" { ... }.
An impl block providing trait or associated items: impl<A> Trait for Data<A> { ... }.
A macro invocation, which includes macro_rules! definitions.
A 2.0-style declarative macro introduced by the macro keyword.
A module or module declaration: mod m or mod m { ... }.
A static item: static BIKE: Shed = Shed(42).
A struct definition: struct Foo<A> { x: A }.
A trait definition: pub trait Iterator { ... }.
A trait alias: pub trait SharableIterator = Iterator + Sync.
A type alias: type Result<T> = std::result::Result<T, MyError>.
A union definition: union Foo<A, B> { x: A, y: B }.
A use declaration: use std::collections::HashMap.
A lifetime labeling a for, while, or loop.
A Rust lifetime: 'a.
A lifetime definition: 'a: 'b + 'c + 'd.
A boolean literal: true or false.
A byte literal: b'f'.
A byte string literal: b"foo".
A character literal: 'a'.
A floating point literal: 1f64 or 1.0e10f64.
An integer literal: 1 or 1u16.
A UTF-8 string literal: "foo".
A local let binding: let x: u64 = s.parse()?.
A macro invocation: println!("{}", mac).
A structured list within an attribute, like derive(Copy, Clone).
A name-value pair within an attribute, like feature = "nightly".
The ::<> explicit type parameters passed to a method call:
parse::<u64>().
Arguments of a function path segment: the (A, B) -> C in Fn(A,B) -> C.
A box pattern: box v.
A pattern that binds a new variable: ref mut binding @ SUBPATTERN.
A literal pattern: 0.
A macro in pattern position.
A pattern that matches any one of a set of cases.
A path pattern like Color::Red, optionally qualified with a
self-type.
A range pattern: 1..=2.
A reference pattern: &mut var.
The dots in a tuple or slice pattern: [0, 1, ..]
A dynamically sized slice pattern: [a, b, ref i @ .., y, z].
A struct or struct variant pattern: Variant { x, y, .. }.
A tuple pattern: (a, b).
A tuple struct or tuple variant pattern: Variant(x, y, .., z).
A type ascription pattern: foo: f64.
A pattern that matches any value: _.
A path at which a named item is exported (e.g. std::collections::HashMap).
A segment of a path together with any path arguments on that segment.
An equality predicate in a where clause (unsupported).
A lifetime predicate in a where clause: 'a: 'b + 'c.
A type predicate in a where clause: for<'c> Foo<'c>: Trait<'c>.
The explicit Self type in a qualified path: the T in <T as Display>::fmt.
The self argument of an associated method, whether taken by value
or by reference.
A function signature in a trait or implementation: unsafe fn initialize(&self).
A trait used as a bound on a type parameter.
An associated constant within the definition of a trait.
A macro invocation within the definition of a trait.
A trait method within the definition of a trait.
An associated type within the definition of a trait.
Returned by TypeGenerics::as_turbofish.
A fixed size array type: [T; n].
A bare function type: fn(usize) -> bool.
Returned by Generics::split_for_impl.
A type contained within invisible delimiters.
An impl Bound1 + Bound2 + Bound3 type where Bound is a trait or
a lifetime.
Indication that a type should be inferred by the compiler: _.
A macro in the type position.
The never type: !.
A generic type parameter: T: Into<String>.
A parenthesized type equivalent to the inner type.
A path like std::slice::Iter, optionally qualified with a
self-type as in <Vec<T> as SomeTrait>::Associated.
A raw pointer type: *const T or *mut T.
A reference type: &'a T or &'a mut T.
A dynamically sized slice type: [T].
A trait object type dyn Bound1 + Bound2 + Bound3 where Bound is a
trait or a lifetime.
A tuple type: (A, B, C, String).
A glob import in a use item: *.
A braced group of imports in a use item: {A, B, C}.
An identifier imported by a use item: HashMap.
A path prefix of imports in a use item: std::....
An renamed identifier imported by a use item: HashMap as Map.
The variadic argument of a foreign function.
An enum variant.
A crate-level visibility: crate.
A public visibility level: pub.
A visibility level restricted to some path: pub(self) or
pub(super) or pub(crate) or pub(in some::module).
A where clause in a definition: where T: Deserialize<'de>, D: 'static.
Distinguishes between attributes that decorate an item and attributes
that are contained within an item.
A binary operator: +, +=, &.
The storage of a struct, enum or union data structure.
A Rust expression.
Data stored within an enum variant or struct.
An argument in a function signature: the n: usize in fn f(n: usize).
An item within an extern block.
An individual generic argument, like 'a, T, or Item = T.
An individual generic argument to a method, like T.
A generic type parameter, lifetime, or const generic: T: Into<String>,
'a: 'b, const LEN: usize.
An item within an impl block.
Things that can appear directly inside of a module or scope.
A Rust literal such as a string or integer or boolean.
A grouping token that surrounds a macro body: m!(...) or m!{...} or m![...].
A struct or tuple struct field accessed in a struct literal or field
expression.
Content of a compile-time structured attribute.
Element of a compile-time attribute list.
A pattern in a local binding, function signature, match expression, or
various other places.
Angle bracketed or parenthesized arguments of a path segment.
Limit types of a range, inclusive or exclusive.
Return type of a function signature.
A statement, usually ending in a semicolon.
The style of a string literal, either plain quoted or a raw string like
r##"data"##.
A modifier on a trait bound, currently only used for the ? in
?Sized.
An item declaration within the definition of a trait.
The possible types that a Rust value could have.
A trait or lifetime used as a bound on a type parameter.
A unary operator: *, !, -.
A suffix of an import tree in a use item: Type as Renamed or *.
The visibility level of an item: inherited or pub or
pub(restricted).
A single predicate in a where clause: T: Deserialize<'de>.