1 mod pin_argument {
2 use pin_project::pin_project;
3
4 #[pin_project]
5 struct Struct {
6 #[pin()] //~ ERROR unexpected token
7 field: (),
8 }
9
10 #[pin_project]
11 struct TupleStruct(#[pin(foo)] ()); //~ ERROR unexpected token
12
13 #[pin_project]
14 enum EnumTuple {
15 V(#[pin(foo)] ()), //~ ERROR unexpected token
16 }
17
18 #[pin_project]
19 enum EnumStruct {
20 V {
21 #[pin(foo)] //~ ERROR unexpected token
22 field: (),
23 },
24 }
25 }
26
27 mod pin_attribute {
28 use pin_project::pin_project;
29
30 #[pin_project]
31 struct DuplicateStruct {
32 #[pin]
33 #[pin] //~ ERROR duplicate #[pin] attribute
34 field: (),
35 }
36
37 #[pin_project]
38 struct DuplicateTupleStruct(
39 #[pin]
40 #[pin]
41 (),
42 //~^^ ERROR duplicate #[pin] attribute
43 );
44
45 #[pin_project]
46 enum DuplicateEnumTuple {
47 V(
48 #[pin]
49 #[pin]
50 (),
51 //~^^ ERROR duplicate #[pin] attribute
52 ),
53 }
54
55 #[pin_project]
56 enum DuplicateEnumStruct {
57 V {
58 #[pin]
59 #[pin] //~ ERROR duplicate #[pin] attribute
60 field: (),
61 },
62 }
63 }
64
65 mod pin_item {
66 use pin_project::pin_project;
67
68 #[pin_project]
69 #[pin] //~ ERROR may only be used on fields of structs or variants
70 struct Struct {
71 #[pin]
72 field: (),
73 }
74
75 #[pin_project]
76 enum Variant {
77 #[pin] //~ ERROR may only be used on fields of structs or variants
78 V(()),
79 }
80
81 #[pin_project]
82 #[pin] //~ ERROR may only be used on fields of structs or variants
83 enum Enum {
84 V(()),
85 }
86 }
87
88 mod pin_project_argument {
89 use pin_project::pin_project;
90
91 #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
92 struct Unexpected1(#[pin] ());
93
94 #[pin_project(Foo)] //~ ERROR unexpected argument
95 struct Unexpected2(#[pin] ());
96
97 #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
98 struct Unexpected3(#[pin] ());
99
100 #[pin_project()] // Ok
101 struct Unexpected4(#[pin] ());
102
103 #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
104 struct Unexpected5(#[pin] ());
105
106 #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
107 struct DuplicatePinnedDrop(#[pin] ());
108
109 #[pin_project(Replace, Replace)] //~ ERROR duplicate `Replace` argument
110 struct DuplicateReplace(#[pin] ());
111
112 #[pin_project(UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
113 struct DuplicateUnsafeUnpin(#[pin] ());
114
115 #[pin_project(!Unpin, !Unpin)] //~ ERROR duplicate `!Unpin` argument
116 struct DuplicateNotUnpin(#[pin] ());
117
118 #[pin_project(PinnedDrop, UnsafeUnpin, UnsafeUnpin)] //~ ERROR duplicate `UnsafeUnpin` argument
119 struct Duplicate3(#[pin] ());
120
121 #[pin_project(PinnedDrop, UnsafeUnpin, PinnedDrop, UnsafeUnpin)] //~ ERROR duplicate `PinnedDrop` argument
122 struct Duplicate4(#[pin] ());
123
124 #[pin_project(project = A, project = B)] //~ ERROR duplicate `project` argument
125 struct DuplicateProject(#[pin] ());
126
127 #[pin_project(project = A, project_ref = A, project = B)] //~ ERROR duplicate `project` argument
128 struct DuplicateProject2(#[pin] ());
129
130 #[pin_project(project_ref = A, project_ref = B)] //~ ERROR duplicate `project_ref` argument
131 struct DuplicateProjectRef(#[pin] ());
132
133 #[pin_project(project_replace = A, project_replace = B)] //~ ERROR duplicate `project_replace` argument
134 struct DuplicateProjectReplace1(#[pin] ());
135
136 #[pin_project(project_replace, project_replace = B)] //~ ERROR duplicate `project_replace` argument
137 struct DuplicateProjectReplace2(#[pin] ());
138
139 #[pin_project(project_replace = A, project_replace)] //~ ERROR duplicate `project_replace` argument
140 struct DuplicateProjectReplace3(#[pin] ());
141
142 #[pin_project(project_replace = A)] // Ok
143 struct ProjectReplaceWithoutReplace(#[pin] ());
144
145 #[pin_project(PinnedDrop, Replace)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
146 struct PinnedDropWithReplace1(#[pin] ());
147
148 #[pin_project(Replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `Replace` are mutually exclusive
149 struct PinnedDropWithReplace2(#[pin] ());
150
151 #[pin_project(PinnedDrop, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
152 struct PinnedDropWithProjectReplace1(#[pin] ());
153
154 #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
155 struct PinnedDropWithProjectReplace2(#[pin] ());
156
157 #[pin_project(project_replace, Replace)] // Ok
158 struct ProjectReplaceWithReplace1(#[pin] ());
159
160 #[pin_project(project_replace = B, Replace)] // Ok
161 struct ProjectReplaceWithReplace2(#[pin] ());
162
163 #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
164 struct UnsafeUnpinWithNotUnpin1(#[pin] ());
165
166 #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
167 struct UnsafeUnpinWithNotUnpin2(#[pin] ());
168
169 #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
170 struct NotUnpin1(#[pin] ());
171
172 #[pin_project(Unpin)] //~ ERROR unexpected argument
173 struct NotUnpin2(#[pin] ());
174
175 #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
176 struct Project1(#[pin] ());
177
178 #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
179 struct Project2(#[pin] ());
180
181 #[pin_project(project = !)] //~ ERROR expected identifier
182 struct Project3(#[pin] ());
183
184 #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
185 struct ProjectRef1(#[pin] ());
186
187 #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
188 struct ProjectRef2(#[pin] ());
189
190 #[pin_project(project_ref = !)] //~ ERROR expected identifier
191 struct ProjectRef3(#[pin] ());
192
193 #[pin_project(project_replace)] // Ok
194 struct ProjectReplace1(#[pin] ());
195
196 #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
197 struct ProjectReplace2(#[pin] ());
198
199 #[pin_project(project_replace = !)] //~ ERROR expected identifier
200 struct ProjectReplace3(#[pin] ());
201 }
202
203 mod pin_project_conflict_naming {
204 use pin_project::pin_project;
205
206 #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
207 struct ProjAndProjRef(#[pin] ());
208
209 #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
210 struct ProjAndProjOwn(#[pin] ());
211
212 #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
213 struct ProjRefAndProjOwn(#[pin] ());
214 }
215
216 mod pin_project_attribute {
217 use pin_project::pin_project;
218
219 #[pin_project]
220 #[pin_project] //~ ERROR duplicate #[pin_project] attribute
221 struct Duplicate(#[pin] ());
222 }
223
224 mod pin_project_item {
225 use pin_project::pin_project;
226
227 #[pin_project]
228 struct Struct {} //~ ERROR may not be used on structs with zero fields
229
230 #[pin_project]
231 struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
232
233 #[pin_project]
234 struct UnitStruct; //~ ERROR may not be used on structs with zero fields
235
236 #[pin_project]
237 enum EnumEmpty {} //~ ERROR may not be used on enums without variants
238
239 #[pin_project]
240 enum EnumDiscriminant {
241 V = 2, //~ ERROR may not be used on enums with discriminants
242 }
243
244 #[pin_project]
245 enum EnumZeroFields {
246 Unit, //~ ERROR may not be used on enums with zero fields
247 Tuple(),
248 Struct {},
249 }
250
251 #[pin_project]
252 union Union {
253 //~^ ERROR may only be used on structs or enums
254 f: (),
255 }
256 }
257
258 // #[repr(packed)] is always detected first, even on unsupported structs.
259 mod pin_project_item_packed {
260 use pin_project::pin_project;
261
262 #[pin_project]
263 #[repr(packed)]
264 struct Struct {} //~ ERROR may not be used on #[repr(packed)] types
265
266 #[pin_project]
267 #[repr(packed)]
268 struct TupleStruct(); //~ ERROR may not be used on #[repr(packed)] types
269
270 #[pin_project]
271 #[repr(packed)]
272 struct UnitStruct; //~ ERROR may not be used on #[repr(packed)] types
273 }
274
main()275 fn main() {}
276