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