Struct syn::Path

pub struct Path {
    pub leading_colon: Option<Colon2>,
    pub segments: Punctuated<PathSegment, Colon2>,
}

A path at which a named item is exported (e.g. std::collections::HashMap).

This type is available only if Syn is built with the "derive" or "full" feature.

Fields

leading_colon: Option<Colon2>

segments: Punctuated<PathSegment, Colon2>

Implementations

impl Path

pub fn parse_mod_style(input: ParseStream<'_>) -> Result<Self>

Parse a Path containing no path arguments on any of its segments.

This function is available only if Syn is built with the "parsing" feature.

Example

use syn::{Path, Result, Token};
use syn::parse::{Parse, ParseStream};

// A simplified single `use` statement like:
//
//     use std::collections::HashMap;
//
// Note that generic parameters are not allowed in a `use` statement
// so the following must not be accepted.
//
//     use a::<b>::c;
struct SingleUse {
    use_token: Token![use],
    path: Path,
}

impl Parse for SingleUse {
    fn parse(input: ParseStream) -> Result<Self> {
        Ok(SingleUse {
            use_token: input.parse()?,
            path: input.call(Path::parse_mod_style)?,
        })
    }
}

pub fn is_ident<I: ?Sized>(&self, ident: &I) -> bool where
    Ident: PartialEq<I>, 

Determines whether this is a path of length 1 equal to the given ident.

For them to compare equal, it must be the case that:

• the path has no leading colon,
• the number of path segments is 1,
• the first path segment has no angle bracketed or parenthesized path arguments, and
• the ident of the first path segment is equal to the given one.

This function is available only if Syn is built with the "parsing" feature.

Example

use syn::{Attribute, Error, Meta, NestedMeta, Result};

fn get_serde_meta_items(attr: &Attribute) -> Result<Vec<NestedMeta>> {
    if attr.path.is_ident("serde") {
        match attr.parse_meta()? {
            Meta::List(meta) => Ok(Vec::from_iter(meta.nested)),
            bad => Err(Error::new_spanned(bad, "unrecognized attribute")),
        }
    } else {
        Ok(Vec::new())
    }
}

pub fn get_ident(&self) -> Option<&Ident>

If this path consists of a single ident, returns the ident.

A path is considered an ident if:

• the path has no leading colon,
• the number of path segments is 1, and
• the first path segment has no angle bracketed or parenthesized path arguments.

This function is available only if Syn is built with the "parsing" feature.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl From<Path> for Meta

fn from(e: Path) -> Meta

Performs the conversion.

impl<T> From<T> for Path where
    T: Into<PathSegment>, 

fn from(segment: T) -> Self

Performs the conversion.

impl Hash for Path

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Parse for Path

fn parse(input: ParseStream<'_>) -> Result<Self>

impl PartialEq<Path> for Path

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl ToTokens for Path

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream object.

impl Eq for Path