Struct rustc_ast::ast::Item

pub struct Item<K = ItemKind> {
    pub attrs: Vec<Attribute>,
    pub id: NodeId,
    pub span: Span,
    pub vis: Visibility,
    pub ident: Ident,
    pub kind: K,
    pub tokens: Option<LazyTokenStream>,
}

An item definition.

Fields

attrs: Vec<Attribute>

id: NodeId

span: Span

vis: Visibility

ident: Ident

The name of the item. It might be a dummy name in case of anonymous items.

kind: K

tokens: Option<LazyTokenStream>

Original tokens this item was parsed from. This isn’t necessarily available for all items, although over time more and more items should have this be Some. Right now this is primarily used for procedural macros, notably custom attributes.

Note that the tokens here do not include the outer attributes, but will include inner attributes.

Implementations

impl Item

pub fn span_with_attributes(&self) -> Span

Return the span that encompasses the attributes.

impl<K: Into<ItemKind>> Item<K>

pub fn into_item(self) -> Item

Trait Implementations

impl AstLike for Item

const SUPPORTS_CUSTOM_INNER_ATTRS: bool

This is true if this AstLike might support ‘custom’ (proc-macro) inner attributes. Attributes like #![cfg] and #![cfg_attr] are not considered ‘custom’ attributes

fn attrs(&self) -> &[Attribute]

fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<Attribute>))

fn tokens_mut(&mut self) -> Option<&mut Option<LazyTokenStream>>

impl<K: Clone> Clone for Item<K>

fn clone(&self) -> Item<K>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug> Debug for Item<K>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, __D: Decoder> Decodable<__D> for Item<K> where
    K: Decodable<__D>, 

fn decode(__decoder: &mut __D) -> Result<Self, <__D as Decoder>::Error>

impl<K, __E: Encoder> Encodable<__E> for Item<K> where
    K: Encodable<__E>, 

fn encode(&self, __encoder: &mut __E) -> Result<(), <__E as Encoder>::Error>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.