telety 0.4.0

Access type information across crates and modules in your proc macros
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#![allow(dead_code)]

use telety::telety;

#[telety(crate::util::types)]
pub struct Simple(pub i32);

#[telety(crate::util::types)]
pub enum MyEnum {
    A,
    B(i32),
    C(i32, i64),
    D(Box<Self>),
    E(()),
    F(Option<u64>),
    G(std::vec::Vec<u8>),
}

#[telety(crate::util::types)]
pub enum MyGeneric<T> {
    A(T),
    B([T; 2]),
    C(Box<Self>),
    D(MyEmpty),
}

#[telety(crate::util::types)]
pub struct A(B, C);

#[telety(crate::util::types)]
pub struct B(i32);

pub struct C;

pub struct MyEmpty;

pub struct NoTelety;

pub trait Gat<'a, A> {
    type Ty<B>;
    type Lifetime<'b>;
    type Both<'b, B: 'b>;
}

impl<'a, A> Gat<'a, A> for i32 {
    type Ty<B> = Option<B>;
    type Lifetime<'b> = &'b i32;
    type Both<'b, B: 'b> = &'b B;
}

#[telety(crate::util::types)]
pub enum AssociatedTypes {
    A(<Option<i32> as IntoIterator>::Item),
    B(<i32 as Gat<'static, u32>>::Ty<i32>),
    C(<i32 as Gat<'static, u32>>::Lifetime<'static>),
    D(<i32 as Gat<'static, u32>>::Both<'static, i32>),
}

#[telety(crate::util::types)]
pub trait GenericParam<Param> {
    fn apply_item(param: Param) -> Param;
}

pub trait PubTrait {}

trait PrivateTrait {}

mod trait_mod {
    pub use super::PubTrait;
}

#[telety(crate::util::types, alias_traits = "always")]
pub trait AlwaysAlias: PubTrait {
    fn f<T: PubTrait>();
}

#[allow(private_bounds)]
#[telety(crate::util::types, alias_traits = "never")]
pub trait NeverAlias: PrivateTrait {
    fn f<T: PrivateTrait>();
}

#[allow(private_bounds)]
#[telety(crate::util::types)]
pub trait AliasMultiPathsOnly: PrivateTrait {
    fn f<T: trait_mod::PubTrait>();
}