Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / rust / crates / syn / 9e801303d0b54cfae85e1750933032b6c84fb31a / . / tests / all.rs
blob: a8a84e1b03b25fedc6c4a18b80d97e85ed5f4d34 [file] [log] [blame]
David Tolnay62a8b692016-09-07 08:18:21 -0700[diff] [blame]1extern crate syn;
David Tolnayee89c1b2016-09-04 16:27:13 -0700[diff] [blame]2
3#[macro_use]
4extern crate quote;
5
6/// These are all of the items from serde_codegen's test suite.
7/// Obnoxious whitespace has been added in an attempt to fool the parser.
8#[test]
9fn test_all() {
10 for s in ITEMS {
David Tolnay62a8b692016-09-07 08:18:21 -0700[diff] [blame]11 let ast = syn::parse_item(s);
David Tolnayee89c1b2016-09-04 16:27:13 -0700[diff] [blame]12 let tokens = quote!(#ast).to_string();
David Tolnay62a8b692016-09-07 08:18:21 -0700[diff] [blame]13 assert_eq!(ast, syn::parse_item(&tokens));
David Tolnayee89c1b2016-09-04 16:27:13 -0700[diff] [blame]14 }
15
16 static ITEMS: &'static [&'static str] = &[
17 r#"
18 # [ derive ( Serialize ) ]
19 #[derive(Deserialize)]
20 struct DefaultStruct <A , B, C, D, E> where C : MyDefault , E: MyDefault {
21 a1 : A,
22 #[serde(default)]
23 a2: B,
24 #[serde(default = "MyDefault::my_default")]
25 a3: C,
26 #[serde(skip_deserializing)]
27 a4: D,
28 #[serde(skip_deserializing, default = "MyDefault::my_default")]
29 a5: E,
30 }
31 "#,
32 r#"
33 #[derive(Serialize)]
34 #[derive(Deserialize)]
35 enum DefaultEnum<A, B, C, D, E> where C: MyDefault, E: MyDefault {
36 Struct {
37 a1: A,
38 #[serde(default)]
39 a2: B,
40 #[serde(default = "MyDefault::my_default")]
41 a3: C,
42 #[serde(skip_deserializing)]
43 a4: D,
44 #[serde(skip_deserializing, default = "MyDefault::my_default")]
45 a5: E,
46 },
47 }
48 "#,
49 r#"
50 #[derive(Deserialize)]
51 struct NoStdDefault(i8);
52 "#,
53 r#"
54 #[derive(Deserialize)]
55 struct ContainsNoStdDefault <A : MyDefault> {
56 #[serde(default = "MyDefault::my_default")]
57 a: A,
58 }
59 "#,
60 r#"
61 #[derive(Deserialize)]
62 struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
63 #[serde(skip_deserializing)]
64 a: A,
65 #[serde(skip_deserializing, default)]
66 b: B,
67 #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)]
68 c: C,
69 #[serde(skip_deserializing, default = "MyDefault::my_default")]
70 e: E,
71 }
72 "#,
73 r#"
74 #[derive(Serialize)]
75 #[serde(deny_unknown_fields)]
76 #[derive(Deserialize)]
77 struct DenyUnknown {
78 a1: i32,
79 }
80 "#,
81 r#"
82 #[derive(Serialize)]
83 #[serde(rename = "Superhero")]
84 #[derive(Deserialize)]
85 struct RenameStruct {
86 a1: i32,
87 #[serde(rename = "a3")]
88 a2: i32,
89 }
90 "#,
91 r#"
92 #[derive(Serialize)]
93 #[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))]
94 #[derive(Deserialize)]
95 struct RenameStructSerializeDeserialize {
96 a1: i32,
97 #[serde(rename(serialize = "a4", deserialize = "a5"))]
98 a2: i32,
99 }
100 "#,
101 r#"
102 #[derive(Serialize)]
103 #[serde(rename = "Superhero")]
104 #[derive(Deserialize)]
105 enum RenameEnum {
106
107 #[serde(rename = "bruce_wayne")]
108 Batman ,
109
110 #[serde(rename = "clark_kent")]
111 Superman ( i8 ) ,
112
113 #[serde(rename = "diana_prince")]
114 WonderWoman ( i8 , i8 ) ,
115
116 #[serde(rename = "barry_allan")]
117 Flash {
118 #[serde(rename = "b")]
119 a : i32,
120 } ,
121 }
122 "#,
123 r#"
124 #[derive(Deserialize)]
125 #[serde ( rename ( serialize = "SuperheroSer" , deserialize = "SuperheroDe" ) ) ]
126 #[derive(Serialize)]
127 enum RenameEnumSerializeDeserialize<A> {
128
129 #[serde(rename(serialize = "dick_grayson", deserialize = "jason_todd"))]
130 Robin {
131 a: i8,
132 #[serde(rename(serialize = "c"))]
133 #[serde(rename(deserialize = "d"))]
134 b: A,
135 },
136 }
137 "#,
138 r#"
139 #[derive(Serialize)]
140 struct SkipSerializingStruct< 'a , B, C> where C : ShouldSkip {
141 a: & 'a i8,
142 #[serde(skip_serializing)]
143 b: B,
144 #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
145 c: C,
146 }
147 "#,
148 r#"
149 #[derive(Serialize)]
150 enum SkipSerializingEnum<'a, B, C> where C: ShouldSkip {
151 Struct {
152 a: &'a i8,
153 #[serde(skip_serializing)]
154 _b: B,
155 #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
156 c: C,
157 },
158 }
159 "#,
160 r#"
161 #[derive(Serialize)]
162 struct ContainsNotSerialize<'a, B, C, D> where B: 'a , D: SerializeWith {
163 a: &'a Option<i8>,
164 #[serde(skip_serializing)]
165 b: &'a B,
166 #[serde(skip_serializing)]
167 c: Option<C>,
168 #[serde(serialize_with = "SerializeWith::serialize_with")]
169 d: D,
170 }
171 "#,
172 r#"
173 #[derive(Serialize)]
174 struct SerializeWithStruct<'a, B> where B: SerializeWith {
175 a: &'a i8,
176 #[serde(serialize_with = "SerializeWith::serialize_with")]
177 b: B,
178 }
179 "#,
180 r#"
181 #[derive(Serialize)]
182 enum SerializeWithEnum<'a, B> where B: SerializeWith {
183 Struct {
184 a: &'a i8,
185 #[serde(serialize_with = "SerializeWith::serialize_with")]
186 b: B,
187 },
188 }
189 "#,
190 r#"
191 #[derive(Deserialize)]
192 struct DeserializeWithStruct<B> where B: DeserializeWith {
193 a: i8,
194 #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
195 b: B,
196 }
197 "#,
198 r#"
199 #[derive(Deserialize)]
200 enum DeserializeWithEnum<B> where B: DeserializeWith {
201 Struct {
202 a: i8,
203 #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
204 b: B,
205 },
206 }
207 "#,
208 r#"
209 #[derive(Deserialize)]
210 enum InvalidLengthEnum {
211 A(i32, i32, i32),
212 B(
213 #[serde(skip_deserializing)]
214 i32, i32, i32),
215 }
216 "#,
217 r#"
218 #[derive(Deserialize)]
219 struct TupleStruct(i32, i32, i32);
220 "#,
221 r#"
222 #[derive(Deserialize)]
223 struct Struct {
224 a: i32,
225 b: i32,
226 #[serde(skip_deserializing)]
227 c: i32,
228 }
229 "#,
230 r#"
231 #[derive(Deserialize)]
232 enum Enum {
233 Unit,
234 Simple(i32),
235 Seq(i32, i32, i32),
236 Map {
237 a: i32,
238 b: i32,
239 c: i32,
240 },
241 }
242 "#,
243 r#"
244 #[derive(Deserialize)]
245 struct IgnoreBase {
246 a: i32,
247 }
248 "#,
249 r#"
250 #[derive(Serialize)]
251 #[derive(Deserialize)]
252 struct With<T> {
253 t: T,
254 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
255 x: X,
256 }
257 "#,
258 r#"
259 #[derive(Serialize)]
260 #[derive(Deserialize)]
261 struct WithRef<'a, T: 'a> {
262 #[serde(skip_deserializing)]
263 t: Option<&'a T>,
264 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
265 x: X,
266 }
267 "#,
268 r#"
269 #[derive(Serialize)]
270 #[derive(Deserialize)]
271 struct PhantomX {
272 x: PhantomData<X>,
273 }
274 "#,
275 r#"
276 #[derive(Serialize)]
277 #[derive(Deserialize)]
278 struct PhantomT<T> {
279 t: PhantomData<T>,
280 }
281 "#,
282 r#"
283 #[derive(Serialize)]
284 #[derive(Deserialize)]
285 struct NoBounds<T> {
286 t: T,
287 option: Option<T>,
288 boxed: Box<T>,
289 option_boxed: Option<Box<T>>,
290 }
291 "#,
292 r#"
293 #[derive(Serialize)]
294 #[derive(Deserialize)]
295 enum EnumWith<T> {
296 Unit,
297 Newtype(
298 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
299 X),
300 Tuple(T,
301 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
302 X),
303 Struct {
304 t: T,
305 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
306 x: X,
307 },
308 }
309 "#,
310 r#"
311 #[derive(Serialize)]
312 struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
313 t: T,
314 rrrt: &'a &'b &'c T,
315 }
316 "#,
317 r#"
318 #[derive(Serialize)]
319 #[derive(Deserialize)]
320 struct Newtype(
321 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
322 X);
323 "#,
324 r#"
325 #[derive(Serialize)]
326 #[derive(Deserialize)]
327 struct Tuple<T>(T,
328 #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
329 X);
330 "#,
331 r#"
332 #[derive(Serialize)]
333 #[derive(Deserialize)]
334 enum TreeNode<D> {
335 Split {
336 left: Box<TreeNode<D>>,
337 right: Box<TreeNode<D>>,
338 },
339 Leaf {
340 data: D,
341 },
342 }
343 "#,
344 r#"
345 #[derive(Serialize)]
346 #[derive(Deserialize)]
347 struct ListNode<D> {
348 data: D,
349 next: Box<ListNode<D>>,
350 }
351 "#,
352 r#"
353 #[derive(Serialize)]
354 #[derive(Deserialize)]
355 struct RecursiveA {
356 b: Box<RecursiveB>,
357 }
358 "#,
359 r#"
360 #[derive(Serialize)]
361 #[derive(Deserialize)]
362 enum RecursiveB { A(RecursiveA), }
363 "#,
364 r#"
365 #[derive(Serialize)]
366 #[derive(Deserialize)]
367 struct RecursiveGenericA<T> {
368 t: T,
369 b: Box<RecursiveGenericB<T>>,
370 }
371 "#,
372 r#"
373 #[derive(Serialize)]
374 #[derive(Deserialize)]
375 enum RecursiveGenericB<T> { T(T), A(RecursiveGenericA<T>), }
376 "#,
377 r#"
378 #[derive(Serialize)]
379 struct OptionStatic<'a> {
380 a: Option<&'a str>,
381 b: Option<&'static str>,
382 }
383 "#,
384 r#"
385 #[derive(Serialize)]
386 #[serde(bound = "D: SerializeWith + DeserializeWith")]
387 #[derive(Deserialize)]
388 struct WithTraits1<D, E> {
389 #[serde(serialize_with = "SerializeWith::serialize_with",
390 deserialize_with = "DeserializeWith::deserialize_with")]
391 d: D,
392 #[serde(serialize_with = "SerializeWith::serialize_with",
393 deserialize_with = "DeserializeWith::deserialize_with",
394 bound = "E: SerializeWith + DeserializeWith")]
395 e: E,
396 }
397 "#,
398 r#"
399 #[derive(Serialize)]
400 #[serde(bound(serialize = "D: SerializeWith",
401 deserialize = "D: DeserializeWith"))]
402 #[derive(Deserialize)]
403 struct WithTraits2<D, E> {
404 #[serde(serialize_with = "SerializeWith::serialize_with",
405 deserialize_with = "DeserializeWith::deserialize_with")]
406 d: D,
407 #[serde(serialize_with = "SerializeWith::serialize_with",
408 bound(serialize = "E: SerializeWith"))]
409 #[serde(deserialize_with = "DeserializeWith::deserialize_with",
410 bound(deserialize = "E: DeserializeWith"))]
411 e: E,
412 }
413 "#,
414 r#"
415 #[derive(Serialize)]
416 #[derive(Deserialize)]
417 struct CowStr<'a>(Cow<'a, str>);
418 "#,
419 r#"
420 #[derive(Serialize)]
421 #[serde(bound(deserialize = "T::Owned: Deserialize"))]
422 #[derive(Deserialize)]
423 struct CowT < 'a , T : ? Sized + 'a + ToOwned > ( Cow < 'a , T > ) ;
424 "#,
425 r#"
426 #[derive(Serialize)]
427 struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
428 "#,
429 r#"
430 #[derive(Deserialize)]
431 struct DeNamedTuple<A, B, C>(A, B, C);
432 "#,
433 r#"
434 #[derive(Serialize)]
435 struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
436 a: &'a A,
437 b: &'b mut B,
438 c: C,
439 }
440 "#,
441 r#"
442 #[derive(Deserialize)]
443 struct DeNamedMap<A, B, C> {
444 a: A,
445 b: < Vec < T > as a :: b :: Trait > :: AssociatedItem,
446 c: < Vec < T > > :: AssociatedItem,
447 }
448 "#,
449 r#"
450 #[derive(Serialize)]
451 enum SerEnum<'a, B: 'a, C: 'a, D> where for < 'a > D: 'a {
452 Unit,
453 Seq(i8, B, &'a C, &'a mut D),
454 Map {
455 a: i8,
456 b: B,
457 c: &'a C,
458 d: &'a mut D,
459 },
460 _Unit2,
461 _Seq2(i8, B, &'a C, &'a mut D),
462 _Map2 {
463 a: i8,
464 b: B,
465 c: &'a C,
466 d: &'a mut D,
467 },
468 }
469 "#,
470 r#"
471 #[derive(Serialize)]
472 #[derive(Deserialize)]
473 enum DeEnum<B, C, D> {
474 Unit,
475 Seq(i8, B, C, D),
476 Map {
477 a: i8,
478 b: B,
479 c: C,
480 d: D,
481 },
482 _Unit2,
483 _Seq2(i8, B, C, D),
484 _Map2 {
485 a: i8,
486 b: B,
487 c: C,
488 d: D,
489 },
490 }
491 "#,
492 r#"
493 #[derive(Serialize)]
494 enum Lifetimes<'a> {
495 LifetimeSeq(&'a i32),
496 NoLifetimeSeq(i32),
497 LifetimeMap {
498 a: &'a i32,
499 },
500 NoLifetimeMap {
501 a: i32,
502 },
503 }
504 "#,
505 r#"
506 #[derive(Serialize)]
507 #[derive(Deserialize)]
508 pub struct GenericStruct<T> {
509 x: T,
510 }
511 "#,
512 r#"
513 #[derive(Serialize)]
514 #[derive(Deserialize)]
515 pub struct GenericNewTypeStruct<T>(T);
516 "#,
517 r#"
518 #[derive(Serialize)]
519 #[derive(Deserialize)]
520 pub struct GenericTupleStruct<T, U>(T, U);
521 "#,
522 r#"
523 #[derive(Serialize)]
524 #[derive(Deserialize)]
525 pub enum GenericEnum<T, U: for < 'a > F<'a>> {
526 Unit,
527 NewType(T),
528 Seq(T, U),
529 Map {
530 x: T,
531 y: U,
532 },
533 }
534 "#,
535 r#"
536 #[derive(Serialize)]
537 #[derive(Deserialize)]
538 struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
539 phantom: std :: marker :: PhantomData<T>,
540 }
541 "#,
542 r#"
543 #[derive(Serialize)]
544 struct UnitStruct;
545 "#,
546 r#"
547 #[derive(Serialize)]
548 struct TupleStruct(i32, i32, i32);
549 "#,
550 r#"
551 #[derive(Serialize)]
552 struct Struct {
553 a: i32,
554 b: i32,
555 c: i32,
556 }
557 "#,
558 r#"
559 #[derive(Serialize)]
560 enum Enum {
561 Unit,
562 One(i32),
563 Seq(i32, i32),
564 Map {
565 a: i32,
566 b: i32,
567 },
568 }
569 "#,
570 r#"
571 #[derive(Serialize)]
572 #[derive(Deserialize)]
573 struct Bounds<T: Serialize + Deserialize> {
574 t: T,
575 option: Option<T>,
576 boxed: Box<T>,
577 option_boxed: Option<Box<T>>,
578 }
579 "#,
580 r#"
581 #[derive(Deserialize)]
582 #[rustc_copy_clone_marker]
583 struct UnitStruct;
584 "#,
585 r#"
586 #[derive(Serialize)]
587 #[allow(dead_code)]
588 #[deny(unused_variables)]
589 enum Void { }
590 "#,
591 r#"
592 #[derive(Serialize)]
593 #[derive(Deserialize)]
594 struct NamedUnit;
595 "#,
596 ];
597}