typed-quote 0.1.1

A fully typed quote!() alternative for both proc-macro and proc-macro2
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::{Never, Span};

use super::*;

impl sealed::MaybeSpan for Never {}
impl MaybeSpan for Never {
    #[cfg(feature = "proc-macro")]
    fn into_span_or_call_site(self) -> proc_macro::Span {
        match self {}
    }
    #[cfg(feature = "proc-macro")]
    fn make_punct(self, _: proc_macro::Punct) -> proc_macro::Punct {
        match self {}
    }
    #[cfg(feature = "proc-macro")]
    fn make_group(self, _: proc_macro::Group) -> proc_macro::Group {
        match self {}
    }
    #[cfg(feature = "proc-macro")]
    fn make_literal(self, _: proc_macro::Literal) -> proc_macro::Literal {
        match self {}
    }

    #[cfg(feature = "proc-macro2")]
    fn into_span2_or_call_site(self) -> proc_macro2::Span {
        match self {}
    }
    #[cfg(feature = "proc-macro2")]
    fn make_punct2(self, _: proc_macro2::Punct) -> proc_macro2::Punct {
        match self {}
    }
    #[cfg(feature = "proc-macro2")]
    fn make_group2(self, _: proc_macro2::Group) -> proc_macro2::Group {
        match self {}
    }
    #[cfg(feature = "proc-macro2")]
    fn make_literal2(self, _: proc_macro2::Literal) -> proc_macro2::Literal {
        match self {}
    }

    type Span = Self;
    fn try_into_span(self) -> Option<Self::Span> {
        match self {}
    }

    type WithDefaultSpan<S: Span> = Self;
    fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S> {
        match self {}
    }

    type WithReplacedSpan<S: Span> = Self;
    fn with_replaced_span<S: Span>(self, _: S) -> Self::WithReplacedSpan<S> {
        match self {}
    }
}

#[cfg(any(feature = "proc-macro", feature = "proc-macro2"))]
impl<T: IntoTokens + WithSpan> crate::replace_span_of::ReplaceSpanOf<T> for Never {
    type ReplaceSpanOf = Never;

    fn replace_span_of(self, _: T) -> Self::ReplaceSpanOf {
        match self {}
    }
}

impl sealed::Span for Never {}
impl Span for Never {}

impl sealed::IntoTokenTree for Never {}
impl IntoTokenTree for Never {
    crate::impl_into_token_tree!(|self| match self {});
}

impl sealed::ToTokenTree for Never {}
impl ToTokenTree for Never {
    crate::impl_to_token_tree!(|self| match *self {});
}

impl sealed::ToTokens for Never {}
impl ToTokens for Never {
    crate::impl_to_tokens!(|self, _| match *self {}, match *self {});
}

impl sealed::IntoTokens for Never {}
impl IntoTokens for Never {
    crate::impl_into_tokens!(|self, _| match self {}, match self {});
}

impl sealed::WithSpan for Never {}
impl WithSpan for Never {
    type WithDefaultSpan<S: Span> = Never;

    fn with_default_span<S: Span>(self, _: S) -> Self::WithDefaultSpan<S> {
        match self {}
    }

    type WithReplacedSpan<S: Span> = Never;

    fn with_replaced_span<S: Span>(self, _: S) -> Self::WithReplacedSpan<S> {
        match self {}
    }
}

impl sealed::RefWithSpan for Never {}
impl RefWithSpan for Never {
    type RefWithDefaultSpan<'a, S: Span>
        = Never
    where
        Self: 'a;

    fn ref_with_default_span<S: Span>(&self, _: S) -> Self::RefWithDefaultSpan<'_, S> {
        match *self {}
    }

    type RefWithReplacedSpan<'a, S: Span>
        = Never
    where
        Self: 'a;

    fn ref_with_replaced_span<S: Span>(&self, _: S) -> Self::RefWithReplacedSpan<'_, S> {
        match *self {}
    }
}