pub struct Attribute {
pub pound_token: Pound,
pub style: AttrStyle,
pub bracket_token: Bracket,
pub path: Path,
pub tts: TokenStream,
}
Expand description
An attribute like #[repr(transparent)]
.
This type is available if Syn is built with the "derive"
or "full"
feature.
Syntax
Rust has six types of attributes.
- Outer attributes like
#[repr(transparent)]
. These appear outside or in front of the item they describe. - Inner attributes like
#![feature(proc_macro)]
. These appear inside of the item they describe, usually a module. - Outer doc comments like
/// # Example
. - Inner doc comments like
//! Please file an issue
. - Outer block comments
/** # Example */
. - Inner block comments
/*! Please file an issue */
.
The style
field of type AttrStyle
distinguishes whether an attribute
is outer or inner. Doc comments and block comments are promoted to
attributes, as this is how they are processed by the compiler and by
macro_rules!
macros.
The path
field gives the possibly colon-delimited path against which
the attribute is resolved. It is equal to "doc"
for desugared doc
comments. The tts
field contains the rest of the attribute body as
tokens.
#[derive(Copy)] #[crate::precondition x < 5]
^^^^^^~~~~~~ ^^^^^^^^^^^^^^^^^^^ ~~~~~
path tts path tts
Use the parse_meta
method to try parsing the tokens of an attribute
into the structured representation that is used by convention across
most Rust libraries.
Parsing
This type does not implement the Parse
trait and thus cannot be
parsed directly by ParseStream::parse
. Instead use
ParseStream::call
with one of the two parser functions
Attribute::parse_outer
or Attribute::parse_inner
depending on
which you intend to parse.
#[macro_use]
extern crate syn;
use syn::{Attribute, Ident};
use syn::parse::{Parse, ParseStream, Result};
// Parses a unit struct with attributes.
//
// #[path = "s.tmpl"]
// struct S;
struct UnitStruct {
attrs: Vec<Attribute>,
struct_token: Token![struct],
name: Ident,
semi_token: Token![;],
}
impl Parse for UnitStruct {
fn parse(input: ParseStream) -> Result<Self> {
Ok(UnitStruct {
attrs: input.call(Attribute::parse_outer)?,
struct_token: input.parse()?,
name: input.parse()?,
semi_token: input.parse()?,
})
}
}
Fields
pound_token: Pound
style: AttrStyle
bracket_token: Bracket
path: Path
tts: TokenStream
Implementations
sourceimpl Attribute
impl Attribute
sourcepub fn parse_meta(&self) -> Result<Meta>
pub fn parse_meta(&self) -> Result<Meta>
Parses the tokens after the path as a Meta
if
possible.
sourcepub fn parse_outer(input: ParseStream<'_>) -> Result<Vec<Self>>
pub fn parse_outer(input: ParseStream<'_>) -> Result<Vec<Self>>
Parses zero or more outer attributes from the stream.
This function is available if Syn is built with the "parsing"
feature.
sourcepub fn parse_inner(input: ParseStream<'_>) -> Result<Vec<Self>>
pub fn parse_inner(input: ParseStream<'_>) -> Result<Vec<Self>>
Parses zero or more inner attributes from the stream.
This function is available if Syn is built with the "parsing"
feature.
Trait Implementations
sourceimpl ToTokens for Attribute
impl ToTokens for Attribute
sourcefn to_tokens(&self, tokens: &mut TokenStream)
fn to_tokens(&self, tokens: &mut TokenStream)
sourcefn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
fn into_token_stream(self) -> TokenStreamwhere
Self: Sized,
impl Eq for Attribute
Auto Trait Implementations
impl RefUnwindSafe for Attribute
impl !Send for Attribute
impl !Sync for Attribute
impl Unpin for Attribute
impl UnwindSafe for Attribute
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> Spanned for Twhere
T: ToTokens,
impl<T> Spanned for Twhere
T: ToTokens,
sourcefn span(&self) -> Span
fn span(&self) -> Span
Span
covering the complete contents of this syntax tree
node, or Span::call_site()
if this node is empty. Read more