1 mod argument {
2     use pin_project::{pin_project, pinned_drop};
3     use std::pin::Pin;
4 
5     #[pin_project(PinnedDrop)]
6     struct UnexpectedArg1(());
7 
8     #[pinned_drop(foo)] //~ ERROR unexpected token
9     impl PinnedDrop for UnexpectedArg1 {
drop(self: Pin<&mut Self>)10         fn drop(self: Pin<&mut Self>) {}
11     }
12 
13     #[pin_project(PinnedDrop)]
14     struct UnexpectedArg2(());
15 
16     #[pinned_drop()] // Ok
17     impl PinnedDrop for UnexpectedArg2 {
drop(self: Pin<&mut Self>)18         fn drop(self: Pin<&mut Self>) {}
19     }
20 }
21 
22 mod attribute {
23     use pin_project::{pin_project, pinned_drop};
24 
25     #[pin_project(PinnedDrop)]
26     struct Duplicate(());
27 
28     #[pinned_drop]
29     #[pinned_drop] //~ ERROR duplicate #[pinned_drop] attribute
30     impl PinnedDrop for Duplicate {
drop(self: Pin<&mut Self>)31         fn drop(self: Pin<&mut Self>) {}
32     }
33 }
34 
35 mod item {
36     use pin_project::{pin_project, pinned_drop};
37 
38     #[pin_project(PinnedDrop)]
39     struct TraitImpl(());
40 
41     #[pinned_drop]
42     impl Drop for TraitImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
43 
44     #[pin_project(PinnedDrop)]
45     struct InherentImpl(());
46 
47     #[pinned_drop]
48     impl InherentImpl {} //~ ERROR may only be used on implementation for the `PinnedDrop` trait
49 
50     #[pinned_drop]
drop(_: Pin<&mut ()>)51     fn drop(_: Pin<&mut ()>) {} //~ ERROR expected `impl`
52 }
53 
54 mod unsafety {
55     use pin_project::{pin_project, pinned_drop};
56 
57     #[pin_project(PinnedDrop)]
58     struct Impl(());
59 
60     #[pinned_drop]
61     unsafe impl PinnedDrop for Impl {
62         //~^ ERROR implementing the trait `PinnedDrop` is not unsafe
drop(self: Pin<&mut Self>)63         fn drop(self: Pin<&mut Self>) {}
64     }
65 
66     #[pin_project(PinnedDrop)]
67     struct Method(());
68 
69     #[pinned_drop]
70     impl PinnedDrop for Method {
drop(self: Pin<&mut Self>)71         unsafe fn drop(self: Pin<&mut Self>) {} //~ ERROR implementing the method `drop` is not unsafe
72     }
73 }
74 
75 mod assoc_item {
76     use pin_project::{pin_project, pinned_drop};
77 
78     #[pin_project(PinnedDrop)]
79     struct Empty(());
80 
81     #[pinned_drop]
82     impl PinnedDrop for Empty {} //~ ERROR not all trait items implemented, missing: `drop`
83 
84     #[pin_project(PinnedDrop)]
85     struct Const1(());
86 
87     #[pinned_drop]
88     impl PinnedDrop for Const1 {
89         const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
drop(self: Pin<&mut Self>)90         fn drop(self: Pin<&mut Self>) {}
91     }
92 
93     #[pin_project(PinnedDrop)]
94     struct Const2(());
95 
96     #[pinned_drop]
97     impl PinnedDrop for Const2 {
drop(self: Pin<&mut Self>)98         fn drop(self: Pin<&mut Self>) {}
99         const A: u8 = 0; //~ ERROR const `A` is not a member of trait `PinnedDrop`
100     }
101 
102     #[pin_project(PinnedDrop)]
103     struct Type1(());
104 
105     #[pinned_drop]
106     impl PinnedDrop for Type1 {
107         type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
drop(self: Pin<&mut Self>)108         fn drop(self: Pin<&mut Self>) {}
109     }
110 
111     #[pin_project(PinnedDrop)]
112     struct Type2(());
113 
114     #[pinned_drop]
115     impl PinnedDrop for Type2 {
drop(self: Pin<&mut Self>)116         fn drop(self: Pin<&mut Self>) {}
117         type A = u8; //~ ERROR type `A` is not a member of trait `PinnedDrop`
118     }
119 
120     #[pin_project(PinnedDrop)]
121     struct Duplicate(());
122 
123     #[pinned_drop]
124     impl PinnedDrop for Duplicate {
drop(self: Pin<&mut Self>)125         fn drop(self: Pin<&mut Self>) {}
drop(self: Pin<&mut Self>)126         fn drop(self: Pin<&mut Self>) {} //~ ERROR duplicate definitions with name `drop`
127     }
128 }
129 
130 mod method {
131     use pin_project::{pin_project, pinned_drop};
132     use std::pin::Pin;
133 
134     #[pin_project(PinnedDrop)]
135     struct RetUnit(());
136 
137     #[pinned_drop]
138     impl PinnedDrop for RetUnit {
drop(self: Pin<&mut Self>) -> ()139         fn drop(self: Pin<&mut Self>) -> () {} // Ok
140     }
141 
142     #[pin_project(PinnedDrop)]
143     struct RetTy(());
144 
145     #[pinned_drop]
146     impl PinnedDrop for RetTy {
drop(self: Pin<&mut Self>) -> Self147         fn drop(self: Pin<&mut Self>) -> Self {} //~ ERROR method `drop` must return the unit type
148     }
149 
150     #[pin_project(PinnedDrop)]
151     struct NoArg(());
152 
153     #[pinned_drop]
154     impl PinnedDrop for NoArg {
drop()155         fn drop() {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
156     }
157 
158     #[pin_project(PinnedDrop)]
159     struct MultiArg(());
160 
161     #[pinned_drop]
162     impl PinnedDrop for MultiArg {
drop(self: Pin<&mut Self>, _: ())163         fn drop(self: Pin<&mut Self>, _: ()) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
164     }
165 
166     #[pin_project(PinnedDrop)]
167     struct InvalidArg1(());
168 
169     #[pinned_drop]
170     impl PinnedDrop for InvalidArg1 {
drop(&mut self)171         fn drop(&mut self) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
172     }
173 
174     #[pin_project(PinnedDrop)]
175     struct InvalidArg2(());
176 
177     #[pinned_drop]
178     impl PinnedDrop for InvalidArg2 {
drop(_: Pin<&mut Self>)179         fn drop(_: Pin<&mut Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
180     }
181 
182     #[pin_project(PinnedDrop)]
183     struct InvalidArg3(());
184 
185     #[pinned_drop]
186     impl PinnedDrop for InvalidArg3 {
drop(self: Pin<&Self>)187         fn drop(self: Pin<&Self>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
188     }
189 
190     #[pin_project(PinnedDrop)]
191     struct InvalidArg4(());
192 
193     #[pinned_drop]
194     impl PinnedDrop for InvalidArg4 {
drop(self: Pin<&mut ()>)195         fn drop(self: Pin<&mut ()>) {} //~ ERROR method `drop` must take an argument `self: Pin<&mut Self>`
196     }
197 
198     #[pin_project(PinnedDrop)]
199     struct InvalidName(());
200 
201     #[pinned_drop]
202     impl PinnedDrop for InvalidName {
pinned_drop(&mut self)203         fn pinned_drop(&mut self) {} //~ ERROR method `pinned_drop` is not a member of trait `PinnedDrop
204     }
205 }
206 
207 mod self_ty {
208     use pin_project::pinned_drop;
209 
210     #[pinned_drop]
211     impl PinnedDrop for () {
212         //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
drop(self: Pin<&mut Self>)213         fn drop(self: Pin<&mut Self>) {}
214     }
215 
216     #[pinned_drop]
217     impl PinnedDrop for &mut A {
218         //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
drop(self: Pin<&mut Self>)219         fn drop(self: Pin<&mut Self>) {}
220     }
221 
222     #[pinned_drop]
223     impl PinnedDrop for [A] {
224         //~^ ERROR implementing the trait `PinnedDrop` on this type is unsupported
drop(self: Pin<&mut Self>)225         fn drop(self: Pin<&mut Self>) {}
226     }
227 }
228 
main()229 fn main() {}
230