Module syn

Source

Expand description

A Rust parser used by procedural macros.

See crate ::syn.

Modules§

buffer: A stably addressed token buffer supporting efficient traversal based on a cheaply copyable cursor.
ext: Extension traits to provide parsing methods on foreign types.
meta: Facility for interpreting structured content inside of an Attribute.
parse: Parsing interface for parsing a token stream into a syntax tree node.
punctuated: A punctuated sequence of syntax tree nodes separated by punctuation.
spanned: A trait that can provide the Span of the complete contents of a syntax tree node.
token: Tokens representing Rust punctuation, keywords, and delimiters.
visit_mut: Syntax tree traversal to mutate an exclusive borrow of a syntax tree in place.

Macros§

Token: A type-macro that expands to the name of the Rust type representation of a given token.
braced: Parse a set of curly braces and expose their content to subsequent parsers.
bracketed: Parse a set of square brackets and expose their content to subsequent parsers.
custom_keyword: Define a type that supports parsing and printing a given identifier as if it were a keyword.
custom_punctuation: Define a type that supports parsing and printing a multi-character symbol as if it were a punctuation token.
parenthesized: Parse a set of parentheses and expose their content to subsequent parsers.
parse_macro_input: Parse the input TokenStream of a macro, triggering a compile error if the tokens fail to parse.
parse_quote: Quasi-quotation macro that accepts input like the quote! macro but uses type inference to figure out a return type for those tokens.
parse_quote_spanned: This macro is parse_quote! + quote_spanned!.

Structs§

Abi: The binary interface of a function: extern "C".
AngleBracketedGenericArguments: Angle bracketed arguments of a path segment: the <K, V> in HashMap<K, V>.
Arm: One arm of a match expression: 0..=10 => { return true; }.
AssocConst: An equality constraint on an associated constant: the PANIC = false in Trait<PANIC = false>.
AssocType: A binding (equality constraint) on an associated type: the Item = u8 in Iterator<Item = u8>.
Attribute: An attribute, like #[repr(transparent)].
BareFnArg: An argument in a function type: the usize in fn(usize) -> bool.
BareVariadic: The variadic argument of a function pointer like fn(usize, ...).
Block: A braced block containing Rust statements.
BoundLifetimes: A set of bound lifetimes: for<'a, 'b, 'c>.
ConstParam: A const generic parameter: const LENGTH: usize.
Constraint: An associated type bound: Iterator<Item: Display>.
DataEnum: An enum input to a proc_macro_derive macro.
DataStruct: A struct input to a proc_macro_derive macro.
DataUnion: An untagged union input to a proc_macro_derive macro.
DeriveInput: Data structure sent to a proc_macro_derive macro.
Error: Error returned when a Syn parser cannot parse the input tokens.
ExprArray: A slice literal expression: [a, b, c, d].
ExprAssign: An assignment expression: a = compute().
ExprAsync: An async block: async { ... }.
ExprAwait: An await expression: fut.await.
ExprBinary: A binary operation: a + b, a += b.
ExprBlock: A blocked scope: { ... }.
ExprBreak: A break, with an optional label to break and an optional expression.
ExprCall: A function call expression: invoke(a, b).
ExprCast: A cast expression: foo as f64.
ExprClosure: A closure expression: |a, b| a + b.
ExprConst: A const block: const { ... }.
ExprContinue: A continue, with an optional label.
ExprField: Access of a named struct field (obj.k) or unnamed tuple struct field (obj.0).
ExprForLoop: A for loop: for pat in expr { ... }.
ExprGroup: An expression contained within invisible delimiters.
ExprIf: An if expression with an optional else block: if expr { ... } else { ... }.
ExprIndex: A square bracketed indexing expression: vector[2].
ExprInfer: The inferred value of a const generic argument, denoted _.
ExprLet: A let guard: let Some(x) = opt.
ExprLit: A literal in place of an expression: 1, "foo".
ExprLoop: Conditionless loop: loop { ... }.
ExprMacro: A macro invocation expression: format!("{}", q).
ExprMatch: A match expression: match n { Some(n) => {}, None => {} }.
ExprMethodCall: A method call expression: x.foo::<T>(a, b).
ExprParen: A parenthesized expression: (a + b).
ExprPath: A path like std::mem::replace possibly containing generic parameters and a qualified self-type.
ExprRange: A range expression: 1..2, 1.., ..2, 1..=2, ..=2.
ExprRawAddr: Address-of operation: &raw const place or &raw mut place.
ExprReference: A referencing operation: &a or &mut a.
ExprRepeat: An array literal constructed from one repeated element: [0u8; N].
ExprReturn: A return, with an optional value to be returned.
ExprStruct: A struct literal expression: Point { x: 1, y: 1 }.
ExprTry: A try-expression: expr?.
ExprTryBlock: A try block: try { ... }.
ExprTuple: A tuple expression: (a, b, c, d).
ExprUnary: A unary operation: !x, *x.
ExprUnsafe: An unsafe block: unsafe { ... }.
ExprWhile: A while loop: while expr { ... }.
ExprYield: A yield expression: yield expr.
Field: A field of a struct or enum variant.
FieldPat: A single field in a struct pattern.
FieldValue: A field-value pair in a struct literal.
FieldsNamed: Named fields of a struct or struct variant such as Point { x: f64, y: f64 }.
FieldsUnnamed: Unnamed fields of a tuple struct or tuple variant such as Some(T).
File: A complete file of Rust source code.
ForeignItemFn: A foreign function in an extern block.
ForeignItemMacro: A macro invocation within an extern block.
ForeignItemStatic: A foreign static item in an extern block: static ext: u8.
ForeignItemType: A foreign type in an extern block: type void.
Generics: Lifetimes and type parameters attached to a declaration of a function, enum, trait, etc.
Ident: A word of Rust code, which may be a keyword or legal variable name.
ImplGenerics: Returned by Generics::split_for_impl.
ImplItemConst: An associated constant within an impl block.
ImplItemFn: An associated function within an impl block.
ImplItemMacro: A macro invocation within an impl block.
ImplItemType: An associated type within an impl block.
Index: The index of an unnamed tuple struct field.
ItemConst: A constant item: const MAX: u16 = 65535.
ItemEnum: An enum definition: enum Foo<A, B> { A(A), B(B) }.
ItemExternCrate: An extern crate item: extern crate serde.
ItemFn: A free-standing function: fn process(n: usize) -> Result<()> { ... }.
ItemForeignMod: A block of foreign items: extern "C" { ... }.
ItemImpl: An impl block providing trait or associated items: impl<A> Trait for Data<A> { ... }.
ItemMacro: A macro invocation, which includes macro_rules! definitions.
ItemMod: A module or module declaration: mod m or mod m { ... }.
ItemStatic: A static item: static BIKE: Shed = Shed(42).
ItemStruct: A struct definition: struct Foo<A> { x: A }.
ItemTrait: A trait definition: pub trait Iterator { ... }.
ItemTraitAlias: A trait alias: pub trait SharableIterator = Iterator + Sync.
ItemType: A type alias: type Result<T> = std::result::Result<T, MyError>.
ItemUnion: A union definition: union Foo<A, B> { x: A, y: B }.
ItemUse: A use declaration: use std::collections::HashMap.
Label: A lifetime labeling a for, while, or loop.
Lifetime: A Rust lifetime: 'a.
LifetimeParam: A lifetime definition: 'a: 'b + 'c + 'd.
LitBool: A boolean literal: true or false.
LitByte: A byte literal: b'f'.
LitByteStr: A byte string literal: b"foo".
LitCStr: A nul-terminated C-string literal: c"foo".
LitChar: A character literal: 'a'.
LitFloat: A floating point literal: 1f64 or 1.0e10f64.
LitInt: An integer literal: 1 or 1u16.
LitStr: A UTF-8 string literal: "foo".
Local: A local let binding: let x: u64 = s.parse()?;.
LocalInit: The expression assigned in a local let binding, including optional diverging else block.
Macro: A macro invocation: println!("{}", mac).
MetaList: A structured list within an attribute, like derive(Copy, Clone).
MetaNameValue: A name-value pair within an attribute, like feature = "nightly".
ParenthesizedGenericArguments: Arguments of a function path segment: the (A, B) -> C in Fn(A,B) -> C.
PatConst: A const block: const { ... }.
PatIdent: A pattern that binds a new variable: ref mut binding @ SUBPATTERN.
PatLit: A literal in place of an expression: 1, "foo".
PatMacro: A macro invocation expression: format!("{}", q).
PatOr: A pattern that matches any one of a set of cases.
PatParen: A parenthesized pattern: (A | B).
PatPath: A path like std::mem::replace possibly containing generic parameters and a qualified self-type.
PatRange: A range expression: 1..2, 1.., ..2, 1..=2, ..=2.
PatReference: A reference pattern: &mut var.
PatRest: The dots in a tuple or slice pattern: [0, 1, ..].
PatSlice: A dynamically sized slice pattern: [a, b, ref i @ .., y, z].
PatStruct: A struct or struct variant pattern: Variant { x, y, .. }.
PatTuple: A tuple pattern: (a, b).
PatTupleStruct: A tuple struct or tuple variant pattern: Variant(x, y, .., z).
PatType: A type ascription pattern: foo: f64.
PatWild: A pattern that matches any value: _.
Path: A path at which a named item is exported (e.g. std::collections::HashMap).
PathSegment: A segment of a path together with any path arguments on that segment.
PreciseCapture: Precise capturing bound: the ‘use<…>’ in impl Trait + use<'a, T>.
PredicateLifetime: A lifetime predicate in a where clause: 'a: 'b + 'c.
PredicateType: A type predicate in a where clause: for<'c> Foo<'c>: Trait<'c>.
QSelf: The explicit Self type in a qualified path: the T in <T as Display>::fmt.
Receiver: The self argument of an associated method.
Signature: A function signature in a trait or implementation: unsafe fn initialize(&self).
StmtMacro: A macro invocation in statement position.
TraitBound: A trait used as a bound on a type parameter.
TraitItemConst: An associated constant within the definition of a trait.
TraitItemFn: An associated function within the definition of a trait.
TraitItemMacro: A macro invocation within the definition of a trait.
TraitItemType: An associated type within the definition of a trait.
Turbofish: Returned by TypeGenerics::as_turbofish.
TypeArray: A fixed size array type: [T; n].
TypeBareFn: A bare function type: fn(usize) -> bool.
TypeGenerics: Returned by Generics::split_for_impl.
TypeGroup: A type contained within invisible delimiters.
TypeImplTrait: An impl Bound1 + Bound2 + Bound3 type where Bound is a trait or a lifetime.
TypeInfer: Indication that a type should be inferred by the compiler: _.
TypeMacro: A macro in the type position.
TypeNever: The never type: !.
TypeParam: A generic type parameter: T: Into<String>.
TypeParen: A parenthesized type equivalent to the inner type.
TypePath: A path like std::slice::Iter, optionally qualified with a self-type as in <Vec<T> as SomeTrait>::Associated.
TypePtr: A raw pointer type: *const T or *mut T.
TypeReference: A reference type: &'a T or &'a mut T.
TypeSlice: A dynamically sized slice type: [T].
TypeTraitObject: A trait object type dyn Bound1 + Bound2 + Bound3 where Bound is a trait or a lifetime.
TypeTuple: A tuple type: (A, B, C, String).
UseGlob: A glob import in a use item: *.
UseGroup: A braced group of imports in a use item: {A, B, C}.
UseName: An identifier imported by a use item: HashMap.
UsePath: A path prefix of imports in a use item: std::....
UseRename: An renamed identifier imported by a use item: HashMap as Map.
Variadic: The variadic argument of a foreign function.
Variant: An enum variant.
VisRestricted: A visibility level restricted to some path: pub(self) or pub(super) or pub(crate) or pub(in some::module).
WhereClause: A where clause in a definition: where T: Deserialize<'de>, D: 'static.

Enums§

AttrStyle: Distinguishes between attributes that decorate an item and attributes that are contained within an item.
BinOp: A binary operator: +, +=, &.
CapturedParam: Single parameter in a precise capturing bound.
Data: The storage of a struct, enum or union data structure.
Expr: A Rust expression.
FieldMutability: Unused, but reserved for RFC 3323 restrictions.
Fields: Data stored within an enum variant or struct.
FnArg: An argument in a function signature: the n: usize in fn f(n: usize).
ForeignItem: An item within an extern block.
GenericArgument: An individual generic argument, like 'a, T, or Item = T.
GenericParam: A generic type parameter, lifetime, or const generic: T: Into<String>, 'a: 'b, const LEN: usize.
ImplItem: An item within an impl block.
ImplRestriction: Unused, but reserved for RFC 3323 restrictions.
Item: Things that can appear directly inside of a module or scope.
Lit: A Rust literal such as a string or integer or boolean.
MacroDelimiter: A grouping token that surrounds a macro body: m!(...) or m!{...} or m![...].
Member: A struct or tuple struct field accessed in a struct literal or field expression.
Meta: Content of a compile-time structured attribute.
Pat: A pattern in a local binding, function signature, match expression, or various other places.
PathArguments: Angle bracketed or parenthesized arguments of a path segment.
PointerMutability: Mutability of a raw pointer (*const T, *mut T), in which non-mutable isn’t the implicit default.
RangeLimits: Limit types of a range, inclusive or exclusive.
ReturnType: Return type of a function signature.
StaticMutability: The mutability of an Item::Static or ForeignItem::Static.
Stmt: A statement, usually ending in a semicolon.
TraitBoundModifier: A modifier on a trait bound, currently only used for the ? in ?Sized.
TraitItem: An item declaration within the definition of a trait.
Type: The possible types that a Rust value could have.
TypeParamBound: A trait or lifetime used as a bound on a type parameter.
UnOp: A unary operator: *, !, -.
UseTree: A suffix of an import tree in a use item: Type as Renamed or *.
Visibility: The visibility level of an item: inherited or pub or pub(restricted).
WherePredicate: A single predicate in a where clause: T: Deserialize<'de>.

Functions§

parse: Parse tokens of source code into the chosen syntax tree node.
parse2: Parse a proc-macro2 token stream into the chosen syntax tree node.
parse_file: Parse the content of a file of Rust code.
parse_str: Parse a string of Rust code into the chosen syntax tree node.

Type Aliases§

Result: The result of a Syn parser.

Module synCopy item path

Modules§

Macros§

Structs§

Enums§

Functions§

Type Aliases§

Module syn