Files
adler32
aho_corasick
ansi_term
atty
backtrace
backtrace_sys
base64
base_x
bitflags
block_buffer
block_padding
bstr
byte_tools
byteorder
bytes
cargo_metadata
cargo_web
cfg_if
clap
cookie
cookie_store
crc32fast
crossbeam_channel
crossbeam_deque
crossbeam_epoch
crossbeam_queue
crossbeam_utils
digest
directories
dirs_sys
dtoa
either
embed_wasm
embed_wasm_build
encoding_rs
env_logger
error_chain
failure
failure_derive
fake_simd
filetime
flate2
fnv
foreign_types
foreign_types_shared
futures
futures_channel
futures_core
futures_cpupool
futures_sink
futures_task
futures_util
generic_array
getrandom
globset
h2
handlebars
headers
headers_core
heck
http
http_body
httparse
humantime
hyper
hyper_tls
idna
ignore
indexmap
inotify
inotify_sys
iovec
itoa
language_tags
lazy_static
lazycell
libc
libflate
lock_api
log
maplit
matches
maybe_uninit
memchr
memmap
memoffset
mime
mime_guess
miniz_oxide
mio
mio_extras
mio_uds
native_tls
net2
notify
num_cpus
opaque_debug
open
openssl
openssl_probe
openssl_sys
parity_wasm
parking_lot
parking_lot_core
pbr
percent_encoding
pest
pest_derive
pest_generator
pest_meta
phf
phf_codegen
phf_generator
phf_shared
pin_project
pin_project_internal
pin_project_lite
pin_utils
ppv_lite86
proc_macro2
publicsuffix
quick_error
quote
rand
rand_chacha
rand_core
rand_hc
rand_isaac
rand_jitter
rand_os
rand_pcg
rand_xorshift
regex
regex_syntax
remove_dir_all
reqwest
rle_decode_fast
rustc_demangle
ryu
safemem
same_file
scoped_tls
scopeguard
semver
semver_parser
serde
serde_derive
serde_json
serde_urlencoded
sha1
sha2
siphasher
slab
smallvec
string
strsim
structopt
structopt_derive
syn
synstructure
take_mut
tar
tempfile
termcolor
textwrap
thread_local
time
tokio
tokio_buf
tokio_codec
tokio_core
tokio_current_thread
tokio_executor
tokio_fs
tokio_io
tokio_reactor
tokio_sync
tokio_tcp
tokio_threadpool
tokio_timer
tokio_tls
tokio_udp
tokio_uds
tokio_util
toml
tower_service
traitobject
try_from
try_lock
typeable
typenum
ucd_trie
unicase
unicode_bidi
unicode_categories
unicode_normalization
unicode_segmentation
unicode_width
unicode_xid
url
uuid
vec_map
walkdir
want
websocket
xattr
 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
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    *,
};

use crate::utils::{SliceExt, CURRENT_PRIVATE_MODULE};

use super::PIN;

// To generate the correct `Unpin` implementation and the projection methods,
// we need to collect the types of the pinned fields.
// However, since proc-macro-attribute is applied before `#[cfg]` and `#[cfg_attr]` on fields,
// we cannot be collecting field types properly at this timing.
// So instead of generating the `Unpin` implementation and the projection methods here,
// delegate their processing to proc-macro-derive.
//
// At this stage, only attributes are parsed and the following attributes are
// added to the attributes of the item.
// * `#[derive(InternalDerive)]` - An internal helper macro that does the above processing.
// * `#[pin(#private(#args))]` - Pass the argument of `#[pin_project]` to proc-macro-derive (`InternalDerive`).

pub(super) fn parse_attribute(args: &TokenStream, input: TokenStream) -> Result<TokenStream> {
    let Input { mut attrs, body } = syn::parse2(input)?;

    let private = Ident::new(CURRENT_PRIVATE_MODULE, Span::call_site());
    attrs.push(syn::parse_quote! {
        #[derive(::pin_project::#private::__PinProjectInternalDerive)]
    });
    // Use `#private` to prevent users from trying to control `InternalDerive` manually.
    // `#private` does not guarantee compatibility between patch versions,
    // so it should be sufficient for this purpose in most cases.
    attrs.push(syn::parse_quote! {
        #[pin(#private(#args))]
    });

    Ok(quote! {
        #(#attrs)*
        #body
    })
}

#[allow(dead_code)] // https://github.com/rust-lang/rust/issues/56750
struct Input {
    attrs: Vec<Attribute>,
    body: TokenStream,
}

impl Parse for Input {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let attrs = input.call(Attribute::parse_outer)?;

        let ahead = input.fork();
        let _vis: Visibility = ahead.parse()?;
        if !ahead.peek(Token![struct]) && !ahead.peek(Token![enum]) {
            // If we check this only on proc-macro-derive, it may generate unhelpful error messages.
            // So it is preferable to be able to detect it here.
            Err(error!(
                input.parse::<TokenStream>()?,
                "#[pin_project] attribute may only be used on structs or enums"
            ))
        } else if let Some(attr) = attrs.find(PIN) {
            Err(error!(attr, "#[pin] attribute may only be used on fields of structs or variants"))
        } else if let Some(attr) = attrs.find("pin_project") {
            Err(error!(attr, "only one #[pin_project] attribute is allowed"))
        } else {
            Ok(Self { attrs, body: input.parse()? })
        }
    }
}