[][src]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: std::collections::HashMap.

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

Fields

leading_colon: Option<Colon2>segments: Punctuated<PathSegment, Colon2>

Methods

impl Path[src]

pub fn parse_mod_style(input: ParseStream) -> Result<Self>[src]

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

This function is available 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>, 
[src]

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 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>[src]

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 if Syn is built with the "parsing" feature.

Trait Implementations

impl Parse for Path[src]

impl From<Path> for Meta[src]

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

impl Clone for Path[src]

impl Eq for Path[src]

impl PartialEq<Path> for Path[src]

impl Debug for Path[src]

impl Hash for Path[src]

impl StructuralPartialEq for Path[src]

impl StructuralEq for Path[src]

impl ToTokens for Path[src]

Auto Trait Implementations

impl !Send for Path

impl !Sync for Path

impl Unpin for Path

impl UnwindSafe for Path

impl !RefUnwindSafe for Path

Blanket Implementations

impl<T> Spanned for T where
    T: Spanned + ?Sized
[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]