Struct devise::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>

Implementations

impl Path

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

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

Trait Implementations

impl Clone for Path

pub 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

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

Formats the value using the given formatter.

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

pub fn from(segment: T) -> Path

Performs the conversion.

impl Hash for Path

pub 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

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

impl PartialEq<Path> for Path

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

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

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

This method tests for !=.

impl PathExt for Path

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

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

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

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

impl ToTokens for Path

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

Write self to the given TokenStream.

fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream object.

impl Eq for Path

impl StructuralEq for Path

impl StructuralPartialEq for Path