diplomat_core/ast/
paths.rs

1use serde::{Deserialize, Serialize};
2use std::fmt;
3
4use super::Ident;
5
6#[derive(Hash, Eq, PartialEq, Deserialize, Serialize, Clone, Debug, Ord, PartialOrd)]
7#[non_exhaustive]
8pub struct Path {
9    pub elements: Vec<Ident>,
10}
11
12impl Path {
13    pub fn get_super(&self) -> Path {
14        let mut new_elements = self.elements.clone();
15        new_elements.remove(new_elements.len() - 1);
16        Path {
17            elements: new_elements,
18        }
19    }
20
21    pub fn sub_path(&self, ident: Ident) -> Path {
22        let mut new_elements = self.elements.clone();
23        new_elements.push(ident);
24        Path {
25            elements: new_elements,
26        }
27    }
28
29    pub fn to_syn(&self) -> syn::Path {
30        syn::Path {
31            leading_colon: None,
32            segments: self
33                .elements
34                .iter()
35                .map(|s| syn::PathSegment {
36                    ident: s.to_syn(),
37                    arguments: syn::PathArguments::None,
38                })
39                .collect(),
40        }
41    }
42
43    pub fn from_syn(path: &syn::Path) -> Path {
44        Path {
45            elements: path
46                .segments
47                .iter()
48                .map(|seg| (&seg.ident).into())
49                .collect(),
50        }
51    }
52
53    pub fn empty() -> Path {
54        Path { elements: vec![] }
55    }
56}
57
58impl fmt::Display for Path {
59    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
60        if let Some((head, tail)) = self.elements.split_first() {
61            head.fmt(f)?;
62            for seg in tail {
63                "::".fmt(f)?;
64                seg.fmt(f)?;
65            }
66        }
67        Ok(())
68    }
69}
70
71impl FromIterator<Ident> for Path {
72    fn from_iter<T: IntoIterator<Item = Ident>>(iter: T) -> Self {
73        Path {
74            elements: iter.into_iter().collect(),
75        }
76    }
77}