Struct Path

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

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

Fields

leading_colon: Option<PathSep>

segments: Punctuated<PathSegment, PathSep>

Implementations

impl Path

pub fn is_ident<I>(&self, ident: &I) -> bool

where Ident: PartialEq<I>, I: ?Sized,

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.

Example

use proc_macro2::TokenStream;
use syn::{Attribute, Error, Meta, Result};

fn get_serde_meta_item(attr: &Attribute) -> Result<Option<&TokenStream>> {
    if attr.path().is_ident("serde") {
        match &attr.meta {
            Meta::List(meta) => Ok(Some(&meta.tokens)),
            bad => Err(Error::new_spanned(bad, "unrecognized attribute")),
        }
    } else {
        Ok(None)
    }
}

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.

pub fn require_ident(&self) -> Result<&Ident, Error>

An error if this path is not a single ident, as defined in get_ident.

impl Path

pub fn parse_mod_style(input: &ParseBuffer<'_>) -> Result<Path, Error>

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

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)?,
        })
    }
}

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

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<(), Error>

Formats the value using the given formatter.

impl From<Path> for Meta

fn from(meta: Path) -> Meta

Converts to this type from the input type.

impl<T> From<T> for Path

where T: Into<PathSegment>,

fn from(segment: T) -> Path

Converts to this type from the input type.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parse for Path

fn parse(input: &ParseBuffer<'_>) -> Result<Path, Error>

impl PartialEq for Path

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PathExt for Path

fn is(&self, global: bool, segments: &[&str]) -> bool

fn is_local(&self, segments: &[&str]) -> bool

fn is_global(&self, segments: &[&str]) -> bool

fn last_ident(&self) -> Option<&Ident>

fn generics(&self) -> Option<&Punctuated<GenericArgument, Comma>>

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

where Self: Sized,

Convert self directly into a TokenStream object.

impl Eq for Path