extern-trait-impl 0.5.0

Proc-macro implementation for extern-trait
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

use proc_macro2::{Span, TokenStream};
use syn::{
    Attribute, Error, Ident, Path, Token, Type, Visibility,
    ext::IdentExt,
    parse::{Parse, ParseStream, Result},
    parse_quote,
    punctuated::Punctuated,
};

/// Parsed arguments for `#[extern_trait(...)]`.
///
/// Supports the following forms:
/// - `#[extern_trait]`
/// - `#[extern_trait(ProxyName)]`
/// - `#[extern_trait(pub ProxyName)]`
/// - `#[extern_trait(crate = path)]`
/// - `#[extern_trait(default = Type, ProxyName)]`
/// - `#[extern_trait(crate = path, ProxyName)]`
/// - `#[extern_trait(ProxyName, crate = path)]`
pub struct Args {
    extern_trait: Path,
    proxy: Option<Proxy>,
    default: Option<Type>,
}

impl Parse for Args {
    fn parse(input: ParseStream) -> Result<Self> {
        let args = Punctuated::<Arg, Token![,]>::parse_terminated(input)?;
        let mut extern_trait = None;
        let mut proxy = None;
        let mut default = None;
        for arg in args {
            match arg {
                Arg::Crate(path) => {
                    if extern_trait.is_some() {
                        return Err(Error::new_spanned(path, "duplicate `crate` argument"));
                    }
                    extern_trait = Some(path);
                }
                Arg::Default(ty) => {
                    if default.is_some() {
                        return Err(Error::new_spanned(ty, "duplicate `default` argument"));
                    }
                    default = Some(ty);
                }
                Arg::Proxy(value) => {
                    if proxy.is_some() {
                        return Err(Error::new_spanned(
                            value.ident,
                            "proxy type specified more than once",
                        ));
                    }
                    proxy = Some(value);
                }
            }
        }

        Ok(Args {
            extern_trait: extern_trait.unwrap_or_else(|| parse_quote!(::extern_trait)),
            proxy,
            default,
        })
    }
}

/// Validated arguments for `#[extern_trait(...)]` on a trait declaration.
pub struct TraitArgs {
    pub extern_trait: Path,
    pub proxy: Proxy,
    pub default: Option<Type>,
}

impl TryFrom<Args> for TraitArgs {
    type Error = Error;

    fn try_from(args: Args) -> Result<Self> {
        let proxy = args.proxy.ok_or_else(|| {
            Error::new(
                Span::call_site(),
                "#[extern_trait] on a trait requires a proxy type",
            )
        })?;

        if let Some(default) = &args.default
            && !cfg!(feature = "nightly-weak")
        {
            return Err(Error::new_spanned(
                default,
                "`default = ...` requires the `nightly-weak` feature and `#![feature(linkage)]`",
            ));
        }

        Ok(TraitArgs {
            extern_trait: args.extern_trait,
            proxy,
            default: args.default,
        })
    }
}

/// Validated arguments for `#[extern_trait(...)]` on an impl block.
pub struct ImplArgs {
    pub extern_trait: Path,
}

impl TryFrom<Args> for ImplArgs {
    type Error = Error;

    fn try_from(args: Args) -> Result<Self> {
        if let Some(default) = args.default {
            return Err(Error::new_spanned(
                default,
                "default implementation is only supported on trait declarations",
            ));
        }

        if let Some(proxy) = args.proxy {
            return Err(Error::new_spanned(
                proxy.ident,
                "proxy type is only supported on trait declarations",
            ));
        }

        Ok(ImplArgs {
            extern_trait: args.extern_trait,
        })
    }
}

pub struct Proxy {
    pub attrs: Vec<Attribute>,
    pub vis: Visibility,
    pub ident: Ident,
}

impl Proxy {
    pub fn expand(&self, extern_trait: &Path) -> TokenStream {
        let Proxy { attrs, vis, ident } = self;

        quote::quote! {
            #(#attrs)*
            #[repr(transparent)]
            #vis struct #ident(#extern_trait::Repr);
        }
    }
}

enum Arg {
    Crate(Path),
    Default(Type),
    Proxy(Proxy),
}

fn parse_named_key(input: ParseStream) -> Result<Option<Ident>> {
    if !(input.peek(Ident::peek_any) && input.peek2(Token![=])) {
        return Ok(None);
    }

    input.call(Ident::parse_any).map(Some)
}

impl Parse for Arg {
    fn parse(input: ParseStream) -> Result<Self> {
        if let Some(key) = parse_named_key(input)? {
            input.parse::<Token![=]>()?;

            return match key.to_string().as_str() {
                "crate" => Ok(Self::Crate(input.call(Path::parse_mod_style)?)),
                "default" => Ok(Self::Default(input.parse()?)),
                _ => Err(Error::new_spanned(key, "unknown #[extern_trait] argument")),
            };
        }

        Ok(Self::Proxy(Proxy {
            attrs: input.call(Attribute::parse_outer)?,
            vis: input.parse()?,
            ident: input.parse()?,
        }))
    }
}