1 mod pin_argument {
2 use pin_project::pin_project;
3
4 #[pin_project]
5 struct Struct {
6 #[pin()] //~ ERROR unexpected token
7 f: (),
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 f: (),
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 f: (),
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 f: (),
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 f: (),
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(Replace)] //~ ERROR `Replace` argument was removed, use `project_replace` argument instead
92 struct RemovedReplace(#[pin] ());
93
94 #[pin_project(UnsafeUnpin,,)] //~ ERROR expected identifier
95 struct Unexpected1(#[pin] ());
96
97 #[pin_project(Foo)] //~ ERROR unexpected argument
98 struct Unexpected2(#[pin] ());
99
100 #[pin_project(,UnsafeUnpin)] //~ ERROR expected identifier
101 struct Unexpected3(#[pin] ());
102
103 #[pin_project()] // Ok
104 struct Unexpected4(#[pin] ());
105
106 #[pin_project(PinnedDrop PinnedDrop)] //~ ERROR expected `,`
107 struct Unexpected5(#[pin] ());
108
109 #[pin_project(PinnedDrop, PinnedDrop)] //~ ERROR duplicate `PinnedDrop` argument
110 struct DuplicatePinnedDrop(#[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, project_replace)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
146 struct PinnedDropWithProjectReplace1(#[pin] ());
147
148 #[pin_project(project_replace, UnsafeUnpin, PinnedDrop)] //~ ERROR arguments `PinnedDrop` and `project_replace` are mutually exclusive
149 struct PinnedDropWithProjectReplace2(#[pin] ());
150
151 #[pin_project(UnsafeUnpin, !Unpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
152 struct UnsafeUnpinWithNotUnpin1(#[pin] ());
153
154 #[pin_project(!Unpin, PinnedDrop, UnsafeUnpin)] //~ ERROR arguments `UnsafeUnpin` and `!Unpin` are mutually exclusive
155 struct UnsafeUnpinWithNotUnpin2(#[pin] ());
156
157 #[pin_project(!)] //~ ERROR expected `!Unpin`, found `!`
158 struct NotUnpin1(#[pin] ());
159
160 #[pin_project(Unpin)] //~ ERROR unexpected argument
161 struct NotUnpin2(#[pin] ());
162
163 #[pin_project(project)] //~ ERROR expected `project = <identifier>`, found `project`
164 struct Project1(#[pin] ());
165
166 #[pin_project(project = )] //~ ERROR expected `project = <identifier>`, found `project =`
167 struct Project2(#[pin] ());
168
169 #[pin_project(project = !)] //~ ERROR expected identifier
170 struct Project3(#[pin] ());
171
172 #[pin_project(project_ref)] //~ ERROR expected `project_ref = <identifier>`, found `project_ref`
173 struct ProjectRef1(#[pin] ());
174
175 #[pin_project(project_ref = )] //~ ERROR expected `project_ref = <identifier>`, found `project_ref =`
176 struct ProjectRef2(#[pin] ());
177
178 #[pin_project(project_ref = !)] //~ ERROR expected identifier
179 struct ProjectRef3(#[pin] ());
180
181 #[pin_project(project_replace)] // Ok
182 struct ProjectReplace1(#[pin] ());
183
184 #[pin_project(project_replace = )] //~ ERROR expected `project_replace = <identifier>`, found `project_replace =`
185 struct ProjectReplace2(#[pin] ());
186
187 #[pin_project(project_replace = !)] //~ ERROR expected identifier
188 struct ProjectReplace3(#[pin] ());
189
190 #[pin_project(project_replace)] //~ ERROR `project_replace` argument requires a value when used on enums
191 enum ProjectReplaceEnum {
192 V(#[pin] ()),
193 }
194 }
195
196 mod pin_project_conflict_naming {
197 use pin_project::pin_project;
198
199 #[pin_project(project = OrigAndProj)] //~ ERROR name `OrigAndProj` is the same as the original type name
200 struct OrigAndProj(#[pin] ());
201
202 #[pin_project(project_ref = OrigAndProjRef)] //~ ERROR name `OrigAndProjRef` is the same as the original type name
203 struct OrigAndProjRef(#[pin] ());
204
205 #[pin_project(project_replace = OrigAndProjOwn)] //~ ERROR name `OrigAndProjOwn` is the same as the original type name
206 struct OrigAndProjOwn(#[pin] ());
207
208 #[pin_project(project = A, project_ref = A)] //~ ERROR name `A` is already specified by `project` argument
209 struct ProjAndProjRef(#[pin] ());
210
211 #[pin_project(project = A, project_replace = A)] //~ ERROR name `A` is already specified by `project` argument
212 struct ProjAndProjOwn(#[pin] ());
213
214 #[pin_project(project_ref = A, project_replace = A)] //~ ERROR name `A` is already specified by `project_ref` argument
215 struct ProjRefAndProjOwn(#[pin] ());
216 }
217
218 mod pin_project_attribute {
219 use pin_project::pin_project;
220
221 #[pin_project]
222 #[pin_project] //~ ERROR duplicate #[pin_project] attribute
223 struct Duplicate(#[pin] ());
224 }
225
226 mod pin_project_item {
227 use pin_project::pin_project;
228
229 #[pin_project]
230 struct Struct {} //~ ERROR may not be used on structs with zero fields
231
232 #[pin_project]
233 struct TupleStruct(); //~ ERROR may not be used on structs with zero fields
234
235 #[pin_project]
236 struct UnitStruct; //~ ERROR may not be used on structs with zero fields
237
238 #[pin_project]
239 enum EnumEmpty {} //~ ERROR may not be used on enums without variants
240
241 #[pin_project]
242 enum EnumDiscriminant {
243 V = 2, //~ ERROR may not be used on enums with discriminants
244 }
245
246 #[pin_project]
247 enum EnumZeroFields {
248 Unit, //~ ERROR may not be used on enums with zero fields
249 Tuple(),
250 Struct {},
251 }
252
253 #[pin_project]
254 union Union {
255 //~^ ERROR may only be used on structs or enums
256 f: (),
257 }
258
259 #[pin_project]
260 impl Impl {} //~ ERROR may only be used on structs or enums
261 }
262
263 // #[repr(packed)] is always detected first, even on unsupported structs.
264 mod pin_project_item_packed {
265 use pin_project::pin_project;
266
267 #[pin_project]
268 #[repr(packed)]
269 struct Struct {} //~ ERROR may not be used on #[repr(packed)] types
270
271 #[pin_project]
272 #[repr(packed)]
273 struct TupleStruct(); //~ ERROR may not be used on #[repr(packed)] types
274
275 #[pin_project]
276 #[repr(packed)]
277 struct UnitStruct; //~ ERROR may not be used on #[repr(packed)] types
278 }
279
main()280 fn main() {}
281