1 use internals::respan::respan;
2 use internals::symbol::*;
3 use internals::{ungroup, Ctxt};
4 use proc_macro2::{Spacing, Span, TokenStream, TokenTree};
5 use quote::ToTokens;
6 use std::borrow::Cow;
7 use std::collections::BTreeSet;
8 use syn;
9 use syn::parse::{self, Parse, ParseStream};
10 use syn::punctuated::Punctuated;
11 use syn::Ident;
12 use syn::Meta::{List, NameValue, Path};
13 use syn::NestedMeta::{Lit, Meta};
14
15 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
16 // are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
17 // `attr::Field::from_ast`. Each returns an instance of the corresponding
18 // struct. Note that none of them return a Result. Unrecognized, malformed, or
19 // duplicated attributes result in a span_err but otherwise are ignored. The
20 // user will see errors simultaneously for all bad attributes in the crate
21 // rather than just the first.
22
23 pub use internals::case::RenameRule;
24
25 struct Attr<'c, T> {
26 cx: &'c Ctxt,
27 name: Symbol,
28 tokens: TokenStream,
29 value: Option<T>,
30 }
31
32 impl<'c, T> Attr<'c, T> {
none(cx: &'c Ctxt, name: Symbol) -> Self33 fn none(cx: &'c Ctxt, name: Symbol) -> Self {
34 Attr {
35 cx,
36 name,
37 tokens: TokenStream::new(),
38 value: None,
39 }
40 }
41
set<A: ToTokens>(&mut self, obj: A, value: T)42 fn set<A: ToTokens>(&mut self, obj: A, value: T) {
43 let tokens = obj.into_token_stream();
44
45 if self.value.is_some() {
46 self.cx
47 .error_spanned_by(tokens, format!("duplicate serde attribute `{}`", self.name));
48 } else {
49 self.tokens = tokens;
50 self.value = Some(value);
51 }
52 }
53
set_opt<A: ToTokens>(&mut self, obj: A, value: Option<T>)54 fn set_opt<A: ToTokens>(&mut self, obj: A, value: Option<T>) {
55 if let Some(value) = value {
56 self.set(obj, value);
57 }
58 }
59
set_if_none(&mut self, value: T)60 fn set_if_none(&mut self, value: T) {
61 if self.value.is_none() {
62 self.value = Some(value);
63 }
64 }
65
get(self) -> Option<T>66 fn get(self) -> Option<T> {
67 self.value
68 }
69
get_with_tokens(self) -> Option<(TokenStream, T)>70 fn get_with_tokens(self) -> Option<(TokenStream, T)> {
71 match self.value {
72 Some(v) => Some((self.tokens, v)),
73 None => None,
74 }
75 }
76 }
77
78 struct BoolAttr<'c>(Attr<'c, ()>);
79
80 impl<'c> BoolAttr<'c> {
none(cx: &'c Ctxt, name: Symbol) -> Self81 fn none(cx: &'c Ctxt, name: Symbol) -> Self {
82 BoolAttr(Attr::none(cx, name))
83 }
84
set_true<A: ToTokens>(&mut self, obj: A)85 fn set_true<A: ToTokens>(&mut self, obj: A) {
86 self.0.set(obj, ());
87 }
88
get(&self) -> bool89 fn get(&self) -> bool {
90 self.0.value.is_some()
91 }
92 }
93
94 struct VecAttr<'c, T> {
95 cx: &'c Ctxt,
96 name: Symbol,
97 first_dup_tokens: TokenStream,
98 values: Vec<T>,
99 }
100
101 impl<'c, T> VecAttr<'c, T> {
none(cx: &'c Ctxt, name: Symbol) -> Self102 fn none(cx: &'c Ctxt, name: Symbol) -> Self {
103 VecAttr {
104 cx,
105 name,
106 first_dup_tokens: TokenStream::new(),
107 values: Vec::new(),
108 }
109 }
110
insert<A: ToTokens>(&mut self, obj: A, value: T)111 fn insert<A: ToTokens>(&mut self, obj: A, value: T) {
112 if self.values.len() == 1 {
113 self.first_dup_tokens = obj.into_token_stream();
114 }
115 self.values.push(value);
116 }
117
at_most_one(mut self) -> Result<Option<T>, ()>118 fn at_most_one(mut self) -> Result<Option<T>, ()> {
119 if self.values.len() > 1 {
120 let dup_token = self.first_dup_tokens;
121 self.cx.error_spanned_by(
122 dup_token,
123 format!("duplicate serde attribute `{}`", self.name),
124 );
125 Err(())
126 } else {
127 Ok(self.values.pop())
128 }
129 }
130
get(self) -> Vec<T>131 fn get(self) -> Vec<T> {
132 self.values
133 }
134 }
135
136 pub struct Name {
137 serialize: String,
138 serialize_renamed: bool,
139 deserialize: String,
140 deserialize_renamed: bool,
141 deserialize_aliases: Vec<String>,
142 }
143
144 #[allow(deprecated)]
unraw(ident: &Ident) -> String145 fn unraw(ident: &Ident) -> String {
146 // str::trim_start_matches was added in 1.30, trim_left_matches deprecated
147 // in 1.33. We currently support rustc back to 1.15 so we need to continue
148 // to use the deprecated one.
149 ident.to_string().trim_left_matches("r#").to_owned()
150 }
151
152 impl Name {
from_attrs( source_name: String, ser_name: Attr<String>, de_name: Attr<String>, de_aliases: Option<VecAttr<String>>, ) -> Name153 fn from_attrs(
154 source_name: String,
155 ser_name: Attr<String>,
156 de_name: Attr<String>,
157 de_aliases: Option<VecAttr<String>>,
158 ) -> Name {
159 let deserialize_aliases = match de_aliases {
160 Some(de_aliases) => {
161 let mut alias_list = BTreeSet::new();
162 for alias_name in de_aliases.get() {
163 alias_list.insert(alias_name);
164 }
165 alias_list.into_iter().collect()
166 }
167 None => Vec::new(),
168 };
169
170 let ser_name = ser_name.get();
171 let ser_renamed = ser_name.is_some();
172 let de_name = de_name.get();
173 let de_renamed = de_name.is_some();
174 Name {
175 serialize: ser_name.unwrap_or_else(|| source_name.clone()),
176 serialize_renamed: ser_renamed,
177 deserialize: de_name.unwrap_or(source_name),
178 deserialize_renamed: de_renamed,
179 deserialize_aliases,
180 }
181 }
182
183 /// Return the container name for the container when serializing.
serialize_name(&self) -> String184 pub fn serialize_name(&self) -> String {
185 self.serialize.clone()
186 }
187
188 /// Return the container name for the container when deserializing.
deserialize_name(&self) -> String189 pub fn deserialize_name(&self) -> String {
190 self.deserialize.clone()
191 }
192
deserialize_aliases(&self) -> Vec<String>193 fn deserialize_aliases(&self) -> Vec<String> {
194 let mut aliases = self.deserialize_aliases.clone();
195 let main_name = self.deserialize_name();
196 if !aliases.contains(&main_name) {
197 aliases.push(main_name);
198 }
199 aliases
200 }
201 }
202
203 pub struct RenameAllRules {
204 serialize: RenameRule,
205 deserialize: RenameRule,
206 }
207
208 /// Represents struct or enum attribute information.
209 pub struct Container {
210 name: Name,
211 transparent: bool,
212 deny_unknown_fields: bool,
213 default: Default,
214 rename_all_rules: RenameAllRules,
215 ser_bound: Option<Vec<syn::WherePredicate>>,
216 de_bound: Option<Vec<syn::WherePredicate>>,
217 tag: TagType,
218 type_from: Option<syn::Type>,
219 type_try_from: Option<syn::Type>,
220 type_into: Option<syn::Type>,
221 remote: Option<syn::Path>,
222 identifier: Identifier,
223 has_flatten: bool,
224 serde_path: Option<syn::Path>,
225 is_packed: bool,
226 /// Error message generated when type can't be deserialized
227 expecting: Option<String>,
228 }
229
230 /// Styles of representing an enum.
231 pub enum TagType {
232 /// The default.
233 ///
234 /// ```json
235 /// {"variant1": {"key1": "value1", "key2": "value2"}}
236 /// ```
237 External,
238
239 /// `#[serde(tag = "type")]`
240 ///
241 /// ```json
242 /// {"type": "variant1", "key1": "value1", "key2": "value2"}
243 /// ```
244 Internal { tag: String },
245
246 /// `#[serde(tag = "t", content = "c")]`
247 ///
248 /// ```json
249 /// {"t": "variant1", "c": {"key1": "value1", "key2": "value2"}}
250 /// ```
251 Adjacent { tag: String, content: String },
252
253 /// `#[serde(untagged)]`
254 ///
255 /// ```json
256 /// {"key1": "value1", "key2": "value2"}
257 /// ```
258 None,
259 }
260
261 /// Whether this enum represents the fields of a struct or the variants of an
262 /// enum.
263 #[derive(Copy, Clone)]
264 pub enum Identifier {
265 /// It does not.
266 No,
267
268 /// This enum represents the fields of a struct. All of the variants must be
269 /// unit variants, except possibly one which is annotated with
270 /// `#[serde(other)]` and is a newtype variant.
271 Field,
272
273 /// This enum represents the variants of an enum. All of the variants must
274 /// be unit variants.
275 Variant,
276 }
277
278 impl Identifier {
279 #[cfg(feature = "deserialize_in_place")]
is_some(self) -> bool280 pub fn is_some(self) -> bool {
281 match self {
282 Identifier::No => false,
283 Identifier::Field | Identifier::Variant => true,
284 }
285 }
286 }
287
288 impl Container {
289 /// Extract out the `#[serde(...)]` attributes from an item.
from_ast(cx: &Ctxt, item: &syn::DeriveInput) -> Self290 pub fn from_ast(cx: &Ctxt, item: &syn::DeriveInput) -> Self {
291 let mut ser_name = Attr::none(cx, RENAME);
292 let mut de_name = Attr::none(cx, RENAME);
293 let mut transparent = BoolAttr::none(cx, TRANSPARENT);
294 let mut deny_unknown_fields = BoolAttr::none(cx, DENY_UNKNOWN_FIELDS);
295 let mut default = Attr::none(cx, DEFAULT);
296 let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
297 let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
298 let mut ser_bound = Attr::none(cx, BOUND);
299 let mut de_bound = Attr::none(cx, BOUND);
300 let mut untagged = BoolAttr::none(cx, UNTAGGED);
301 let mut internal_tag = Attr::none(cx, TAG);
302 let mut content = Attr::none(cx, CONTENT);
303 let mut type_from = Attr::none(cx, FROM);
304 let mut type_try_from = Attr::none(cx, TRY_FROM);
305 let mut type_into = Attr::none(cx, INTO);
306 let mut remote = Attr::none(cx, REMOTE);
307 let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
308 let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
309 let mut serde_path = Attr::none(cx, CRATE);
310 let mut expecting = Attr::none(cx, EXPECTING);
311
312 for meta_item in item
313 .attrs
314 .iter()
315 .flat_map(|attr| get_serde_meta_items(cx, attr))
316 .flatten()
317 {
318 match &meta_item {
319 // Parse `#[serde(rename = "foo")]`
320 Meta(NameValue(m)) if m.path == RENAME => {
321 if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
322 ser_name.set(&m.path, s.value());
323 de_name.set(&m.path, s.value());
324 }
325 }
326
327 // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
328 Meta(List(m)) if m.path == RENAME => {
329 if let Ok((ser, de)) = get_renames(cx, &m.nested) {
330 ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
331 de_name.set_opt(&m.path, de.map(syn::LitStr::value));
332 }
333 }
334
335 // Parse `#[serde(rename_all = "foo")]`
336 Meta(NameValue(m)) if m.path == RENAME_ALL => {
337 if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
338 match RenameRule::from_str(&s.value()) {
339 Ok(rename_rule) => {
340 rename_all_ser_rule.set(&m.path, rename_rule);
341 rename_all_de_rule.set(&m.path, rename_rule);
342 }
343 Err(err) => cx.error_spanned_by(s, err),
344 }
345 }
346 }
347
348 // Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
349 Meta(List(m)) if m.path == RENAME_ALL => {
350 if let Ok((ser, de)) = get_renames(cx, &m.nested) {
351 if let Some(ser) = ser {
352 match RenameRule::from_str(&ser.value()) {
353 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
354 Err(err) => cx.error_spanned_by(ser, err),
355 }
356 }
357 if let Some(de) = de {
358 match RenameRule::from_str(&de.value()) {
359 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
360 Err(err) => cx.error_spanned_by(de, err),
361 }
362 }
363 }
364 }
365
366 // Parse `#[serde(transparent)]`
367 Meta(Path(word)) if word == TRANSPARENT => {
368 transparent.set_true(word);
369 }
370
371 // Parse `#[serde(deny_unknown_fields)]`
372 Meta(Path(word)) if word == DENY_UNKNOWN_FIELDS => {
373 deny_unknown_fields.set_true(word);
374 }
375
376 // Parse `#[serde(default)]`
377 Meta(Path(word)) if word == DEFAULT => match &item.data {
378 syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
379 syn::Fields::Named(_) => {
380 default.set(word, Default::Default);
381 }
382 syn::Fields::Unnamed(_) | syn::Fields::Unit => cx.error_spanned_by(
383 fields,
384 "#[serde(default)] can only be used on structs with named fields",
385 ),
386 },
387 syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx.error_spanned_by(
388 enum_token,
389 "#[serde(default)] can only be used on structs with named fields",
390 ),
391 syn::Data::Union(syn::DataUnion { union_token, .. }) => cx.error_spanned_by(
392 union_token,
393 "#[serde(default)] can only be used on structs with named fields",
394 ),
395 },
396
397 // Parse `#[serde(default = "...")]`
398 Meta(NameValue(m)) if m.path == DEFAULT => {
399 if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
400 match &item.data {
401 syn::Data::Struct(syn::DataStruct { fields, .. }) => {
402 match fields {
403 syn::Fields::Named(_) => {
404 default.set(&m.path, Default::Path(path));
405 }
406 syn::Fields::Unnamed(_) | syn::Fields::Unit => cx
407 .error_spanned_by(
408 fields,
409 "#[serde(default = \"...\")] can only be used on structs with named fields",
410 ),
411 }
412 }
413 syn::Data::Enum(syn::DataEnum { enum_token, .. }) => cx
414 .error_spanned_by(
415 enum_token,
416 "#[serde(default = \"...\")] can only be used on structs with named fields",
417 ),
418 syn::Data::Union(syn::DataUnion {
419 union_token, ..
420 }) => cx.error_spanned_by(
421 union_token,
422 "#[serde(default = \"...\")] can only be used on structs with named fields",
423 ),
424 }
425 }
426 }
427
428 // Parse `#[serde(bound = "T: SomeBound")]`
429 Meta(NameValue(m)) if m.path == BOUND => {
430 if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
431 ser_bound.set(&m.path, where_predicates.clone());
432 de_bound.set(&m.path, where_predicates);
433 }
434 }
435
436 // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
437 Meta(List(m)) if m.path == BOUND => {
438 if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
439 ser_bound.set_opt(&m.path, ser);
440 de_bound.set_opt(&m.path, de);
441 }
442 }
443
444 // Parse `#[serde(untagged)]`
445 Meta(Path(word)) if word == UNTAGGED => match item.data {
446 syn::Data::Enum(_) => {
447 untagged.set_true(word);
448 }
449 syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
450 cx.error_spanned_by(
451 struct_token,
452 "#[serde(untagged)] can only be used on enums",
453 );
454 }
455 syn::Data::Union(syn::DataUnion { union_token, .. }) => {
456 cx.error_spanned_by(
457 union_token,
458 "#[serde(untagged)] can only be used on enums",
459 );
460 }
461 },
462
463 // Parse `#[serde(tag = "type")]`
464 Meta(NameValue(m)) if m.path == TAG => {
465 if let Ok(s) = get_lit_str(cx, TAG, &m.lit) {
466 match &item.data {
467 syn::Data::Enum(_) => {
468 internal_tag.set(&m.path, s.value());
469 }
470 syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
471 syn::Fields::Named(_) => {
472 internal_tag.set(&m.path, s.value());
473 }
474 syn::Fields::Unnamed(_) | syn::Fields::Unit => {
475 cx.error_spanned_by(
476 fields,
477 "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
478 );
479 }
480 },
481 syn::Data::Union(syn::DataUnion { union_token, .. }) => {
482 cx.error_spanned_by(
483 union_token,
484 "#[serde(tag = \"...\")] can only be used on enums and structs with named fields",
485 );
486 }
487 }
488 }
489 }
490
491 // Parse `#[serde(content = "c")]`
492 Meta(NameValue(m)) if m.path == CONTENT => {
493 if let Ok(s) = get_lit_str(cx, CONTENT, &m.lit) {
494 match &item.data {
495 syn::Data::Enum(_) => {
496 content.set(&m.path, s.value());
497 }
498 syn::Data::Struct(syn::DataStruct { struct_token, .. }) => {
499 cx.error_spanned_by(
500 struct_token,
501 "#[serde(content = \"...\")] can only be used on enums",
502 );
503 }
504 syn::Data::Union(syn::DataUnion { union_token, .. }) => {
505 cx.error_spanned_by(
506 union_token,
507 "#[serde(content = \"...\")] can only be used on enums",
508 );
509 }
510 }
511 }
512 }
513
514 // Parse `#[serde(from = "Type")]
515 Meta(NameValue(m)) if m.path == FROM => {
516 if let Ok(from_ty) = parse_lit_into_ty(cx, FROM, &m.lit) {
517 type_from.set_opt(&m.path, Some(from_ty));
518 }
519 }
520
521 // Parse `#[serde(try_from = "Type")]
522 Meta(NameValue(m)) if m.path == TRY_FROM => {
523 if let Ok(try_from_ty) = parse_lit_into_ty(cx, TRY_FROM, &m.lit) {
524 type_try_from.set_opt(&m.path, Some(try_from_ty));
525 }
526 }
527
528 // Parse `#[serde(into = "Type")]
529 Meta(NameValue(m)) if m.path == INTO => {
530 if let Ok(into_ty) = parse_lit_into_ty(cx, INTO, &m.lit) {
531 type_into.set_opt(&m.path, Some(into_ty));
532 }
533 }
534
535 // Parse `#[serde(remote = "...")]`
536 Meta(NameValue(m)) if m.path == REMOTE => {
537 if let Ok(path) = parse_lit_into_path(cx, REMOTE, &m.lit) {
538 if is_primitive_path(&path, "Self") {
539 remote.set(&m.path, item.ident.clone().into());
540 } else {
541 remote.set(&m.path, path);
542 }
543 }
544 }
545
546 // Parse `#[serde(field_identifier)]`
547 Meta(Path(word)) if word == FIELD_IDENTIFIER => {
548 field_identifier.set_true(word);
549 }
550
551 // Parse `#[serde(variant_identifier)]`
552 Meta(Path(word)) if word == VARIANT_IDENTIFIER => {
553 variant_identifier.set_true(word);
554 }
555
556 // Parse `#[serde(crate = "foo")]`
557 Meta(NameValue(m)) if m.path == CRATE => {
558 if let Ok(path) = parse_lit_into_path(cx, CRATE, &m.lit) {
559 serde_path.set(&m.path, path);
560 }
561 }
562
563 // Parse `#[serde(expecting = "a message")]`
564 Meta(NameValue(m)) if m.path == EXPECTING => {
565 if let Ok(s) = get_lit_str(cx, EXPECTING, &m.lit) {
566 expecting.set(&m.path, s.value());
567 }
568 }
569
570 Meta(meta_item) => {
571 let path = meta_item
572 .path()
573 .into_token_stream()
574 .to_string()
575 .replace(' ', "");
576 cx.error_spanned_by(
577 meta_item.path(),
578 format!("unknown serde container attribute `{}`", path),
579 );
580 }
581
582 Lit(lit) => {
583 cx.error_spanned_by(lit, "unexpected literal in serde container attribute");
584 }
585 }
586 }
587
588 let mut is_packed = false;
589 for attr in &item.attrs {
590 if attr.path.is_ident("repr") {
591 let _ = attr.parse_args_with(|input: ParseStream| {
592 while let Some(token) = input.parse()? {
593 if let TokenTree::Ident(ident) = token {
594 is_packed |= ident == "packed";
595 }
596 }
597 Ok(())
598 });
599 }
600 }
601
602 Container {
603 name: Name::from_attrs(unraw(&item.ident), ser_name, de_name, None),
604 transparent: transparent.get(),
605 deny_unknown_fields: deny_unknown_fields.get(),
606 default: default.get().unwrap_or(Default::None),
607 rename_all_rules: RenameAllRules {
608 serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
609 deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
610 },
611 ser_bound: ser_bound.get(),
612 de_bound: de_bound.get(),
613 tag: decide_tag(cx, item, untagged, internal_tag, content),
614 type_from: type_from.get(),
615 type_try_from: type_try_from.get(),
616 type_into: type_into.get(),
617 remote: remote.get(),
618 identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
619 has_flatten: false,
620 serde_path: serde_path.get(),
621 is_packed,
622 expecting: expecting.get(),
623 }
624 }
625
name(&self) -> &Name626 pub fn name(&self) -> &Name {
627 &self.name
628 }
629
rename_all_rules(&self) -> &RenameAllRules630 pub fn rename_all_rules(&self) -> &RenameAllRules {
631 &self.rename_all_rules
632 }
633
transparent(&self) -> bool634 pub fn transparent(&self) -> bool {
635 self.transparent
636 }
637
deny_unknown_fields(&self) -> bool638 pub fn deny_unknown_fields(&self) -> bool {
639 self.deny_unknown_fields
640 }
641
default(&self) -> &Default642 pub fn default(&self) -> &Default {
643 &self.default
644 }
645
ser_bound(&self) -> Option<&[syn::WherePredicate]>646 pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
647 self.ser_bound.as_ref().map(|vec| &vec[..])
648 }
649
de_bound(&self) -> Option<&[syn::WherePredicate]>650 pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
651 self.de_bound.as_ref().map(|vec| &vec[..])
652 }
653
tag(&self) -> &TagType654 pub fn tag(&self) -> &TagType {
655 &self.tag
656 }
657
type_from(&self) -> Option<&syn::Type>658 pub fn type_from(&self) -> Option<&syn::Type> {
659 self.type_from.as_ref()
660 }
661
type_try_from(&self) -> Option<&syn::Type>662 pub fn type_try_from(&self) -> Option<&syn::Type> {
663 self.type_try_from.as_ref()
664 }
665
type_into(&self) -> Option<&syn::Type>666 pub fn type_into(&self) -> Option<&syn::Type> {
667 self.type_into.as_ref()
668 }
669
remote(&self) -> Option<&syn::Path>670 pub fn remote(&self) -> Option<&syn::Path> {
671 self.remote.as_ref()
672 }
673
is_packed(&self) -> bool674 pub fn is_packed(&self) -> bool {
675 self.is_packed
676 }
677
identifier(&self) -> Identifier678 pub fn identifier(&self) -> Identifier {
679 self.identifier
680 }
681
has_flatten(&self) -> bool682 pub fn has_flatten(&self) -> bool {
683 self.has_flatten
684 }
685
mark_has_flatten(&mut self)686 pub fn mark_has_flatten(&mut self) {
687 self.has_flatten = true;
688 }
689
custom_serde_path(&self) -> Option<&syn::Path>690 pub fn custom_serde_path(&self) -> Option<&syn::Path> {
691 self.serde_path.as_ref()
692 }
693
serde_path(&self) -> Cow<syn::Path>694 pub fn serde_path(&self) -> Cow<syn::Path> {
695 self.custom_serde_path()
696 .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
697 }
698
699 /// Error message generated when type can't be deserialized.
700 /// If `None`, default message will be used
expecting(&self) -> Option<&str>701 pub fn expecting(&self) -> Option<&str> {
702 self.expecting.as_ref().map(String::as_ref)
703 }
704 }
705
decide_tag( cx: &Ctxt, item: &syn::DeriveInput, untagged: BoolAttr, internal_tag: Attr<String>, content: Attr<String>, ) -> TagType706 fn decide_tag(
707 cx: &Ctxt,
708 item: &syn::DeriveInput,
709 untagged: BoolAttr,
710 internal_tag: Attr<String>,
711 content: Attr<String>,
712 ) -> TagType {
713 match (
714 untagged.0.get_with_tokens(),
715 internal_tag.get_with_tokens(),
716 content.get_with_tokens(),
717 ) {
718 (None, None, None) => TagType::External,
719 (Some(_), None, None) => TagType::None,
720 (None, Some((_, tag)), None) => {
721 // Check that there are no tuple variants.
722 if let syn::Data::Enum(data) = &item.data {
723 for variant in &data.variants {
724 match &variant.fields {
725 syn::Fields::Named(_) | syn::Fields::Unit => {}
726 syn::Fields::Unnamed(fields) => {
727 if fields.unnamed.len() != 1 {
728 cx.error_spanned_by(
729 variant,
730 "#[serde(tag = \"...\")] cannot be used with tuple variants",
731 );
732 break;
733 }
734 }
735 }
736 }
737 }
738 TagType::Internal { tag }
739 }
740 (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => {
741 cx.error_spanned_by(
742 untagged_tokens,
743 "enum cannot be both untagged and internally tagged",
744 );
745 cx.error_spanned_by(
746 tag_tokens,
747 "enum cannot be both untagged and internally tagged",
748 );
749 TagType::External // doesn't matter, will error
750 }
751 (None, None, Some((content_tokens, _))) => {
752 cx.error_spanned_by(
753 content_tokens,
754 "#[serde(tag = \"...\", content = \"...\")] must be used together",
755 );
756 TagType::External
757 }
758 (Some((untagged_tokens, _)), None, Some((content_tokens, _))) => {
759 cx.error_spanned_by(
760 untagged_tokens,
761 "untagged enum cannot have #[serde(content = \"...\")]",
762 );
763 cx.error_spanned_by(
764 content_tokens,
765 "untagged enum cannot have #[serde(content = \"...\")]",
766 );
767 TagType::External
768 }
769 (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content },
770 (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => {
771 cx.error_spanned_by(
772 untagged_tokens,
773 "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
774 );
775 cx.error_spanned_by(
776 tag_tokens,
777 "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
778 );
779 cx.error_spanned_by(
780 content_tokens,
781 "untagged enum cannot have #[serde(tag = \"...\", content = \"...\")]",
782 );
783 TagType::External
784 }
785 }
786 }
787
decide_identifier( cx: &Ctxt, item: &syn::DeriveInput, field_identifier: BoolAttr, variant_identifier: BoolAttr, ) -> Identifier788 fn decide_identifier(
789 cx: &Ctxt,
790 item: &syn::DeriveInput,
791 field_identifier: BoolAttr,
792 variant_identifier: BoolAttr,
793 ) -> Identifier {
794 match (
795 &item.data,
796 field_identifier.0.get_with_tokens(),
797 variant_identifier.0.get_with_tokens(),
798 ) {
799 (_, None, None) => Identifier::No,
800 (_, Some((field_identifier_tokens, _)), Some((variant_identifier_tokens, _))) => {
801 cx.error_spanned_by(
802 field_identifier_tokens,
803 "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
804 );
805 cx.error_spanned_by(
806 variant_identifier_tokens,
807 "#[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set",
808 );
809 Identifier::No
810 }
811 (syn::Data::Enum(_), Some(_), None) => Identifier::Field,
812 (syn::Data::Enum(_), None, Some(_)) => Identifier::Variant,
813 (syn::Data::Struct(syn::DataStruct { struct_token, .. }), Some(_), None) => {
814 cx.error_spanned_by(
815 struct_token,
816 "#[serde(field_identifier)] can only be used on an enum",
817 );
818 Identifier::No
819 }
820 (syn::Data::Union(syn::DataUnion { union_token, .. }), Some(_), None) => {
821 cx.error_spanned_by(
822 union_token,
823 "#[serde(field_identifier)] can only be used on an enum",
824 );
825 Identifier::No
826 }
827 (syn::Data::Struct(syn::DataStruct { struct_token, .. }), None, Some(_)) => {
828 cx.error_spanned_by(
829 struct_token,
830 "#[serde(variant_identifier)] can only be used on an enum",
831 );
832 Identifier::No
833 }
834 (syn::Data::Union(syn::DataUnion { union_token, .. }), None, Some(_)) => {
835 cx.error_spanned_by(
836 union_token,
837 "#[serde(variant_identifier)] can only be used on an enum",
838 );
839 Identifier::No
840 }
841 }
842 }
843
844 /// Represents variant attribute information
845 pub struct Variant {
846 name: Name,
847 rename_all_rules: RenameAllRules,
848 ser_bound: Option<Vec<syn::WherePredicate>>,
849 de_bound: Option<Vec<syn::WherePredicate>>,
850 skip_deserializing: bool,
851 skip_serializing: bool,
852 other: bool,
853 serialize_with: Option<syn::ExprPath>,
854 deserialize_with: Option<syn::ExprPath>,
855 borrow: Option<syn::Meta>,
856 }
857
858 impl Variant {
from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self859 pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
860 let mut ser_name = Attr::none(cx, RENAME);
861 let mut de_name = Attr::none(cx, RENAME);
862 let mut de_aliases = VecAttr::none(cx, RENAME);
863 let mut skip_deserializing = BoolAttr::none(cx, SKIP_DESERIALIZING);
864 let mut skip_serializing = BoolAttr::none(cx, SKIP_SERIALIZING);
865 let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
866 let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
867 let mut ser_bound = Attr::none(cx, BOUND);
868 let mut de_bound = Attr::none(cx, BOUND);
869 let mut other = BoolAttr::none(cx, OTHER);
870 let mut serialize_with = Attr::none(cx, SERIALIZE_WITH);
871 let mut deserialize_with = Attr::none(cx, DESERIALIZE_WITH);
872 let mut borrow = Attr::none(cx, BORROW);
873
874 for meta_item in variant
875 .attrs
876 .iter()
877 .flat_map(|attr| get_serde_meta_items(cx, attr))
878 .flatten()
879 {
880 match &meta_item {
881 // Parse `#[serde(rename = "foo")]`
882 Meta(NameValue(m)) if m.path == RENAME => {
883 if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
884 ser_name.set(&m.path, s.value());
885 de_name.set_if_none(s.value());
886 de_aliases.insert(&m.path, s.value());
887 }
888 }
889
890 // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
891 Meta(List(m)) if m.path == RENAME => {
892 if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
893 ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
894 for de_value in de {
895 de_name.set_if_none(de_value.value());
896 de_aliases.insert(&m.path, de_value.value());
897 }
898 }
899 }
900
901 // Parse `#[serde(alias = "foo")]`
902 Meta(NameValue(m)) if m.path == ALIAS => {
903 if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
904 de_aliases.insert(&m.path, s.value());
905 }
906 }
907
908 // Parse `#[serde(rename_all = "foo")]`
909 Meta(NameValue(m)) if m.path == RENAME_ALL => {
910 if let Ok(s) = get_lit_str(cx, RENAME_ALL, &m.lit) {
911 match RenameRule::from_str(&s.value()) {
912 Ok(rename_rule) => {
913 rename_all_ser_rule.set(&m.path, rename_rule);
914 rename_all_de_rule.set(&m.path, rename_rule);
915 }
916 Err(err) => cx.error_spanned_by(s, err),
917 }
918 }
919 }
920
921 // Parse `#[serde(rename_all(serialize = "foo", deserialize = "bar"))]`
922 Meta(List(m)) if m.path == RENAME_ALL => {
923 if let Ok((ser, de)) = get_renames(cx, &m.nested) {
924 if let Some(ser) = ser {
925 match RenameRule::from_str(&ser.value()) {
926 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
927 Err(err) => cx.error_spanned_by(ser, err),
928 }
929 }
930 if let Some(de) = de {
931 match RenameRule::from_str(&de.value()) {
932 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
933 Err(err) => cx.error_spanned_by(de, err),
934 }
935 }
936 }
937 }
938
939 // Parse `#[serde(skip)]`
940 Meta(Path(word)) if word == SKIP => {
941 skip_serializing.set_true(word);
942 skip_deserializing.set_true(word);
943 }
944
945 // Parse `#[serde(skip_deserializing)]`
946 Meta(Path(word)) if word == SKIP_DESERIALIZING => {
947 skip_deserializing.set_true(word);
948 }
949
950 // Parse `#[serde(skip_serializing)]`
951 Meta(Path(word)) if word == SKIP_SERIALIZING => {
952 skip_serializing.set_true(word);
953 }
954
955 // Parse `#[serde(other)]`
956 Meta(Path(word)) if word == OTHER => {
957 other.set_true(word);
958 }
959
960 // Parse `#[serde(bound = "T: SomeBound")]`
961 Meta(NameValue(m)) if m.path == BOUND => {
962 if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
963 ser_bound.set(&m.path, where_predicates.clone());
964 de_bound.set(&m.path, where_predicates);
965 }
966 }
967
968 // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
969 Meta(List(m)) if m.path == BOUND => {
970 if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
971 ser_bound.set_opt(&m.path, ser);
972 de_bound.set_opt(&m.path, de);
973 }
974 }
975
976 // Parse `#[serde(with = "...")]`
977 Meta(NameValue(m)) if m.path == WITH => {
978 if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
979 let mut ser_path = path.clone();
980 ser_path
981 .path
982 .segments
983 .push(Ident::new("serialize", Span::call_site()).into());
984 serialize_with.set(&m.path, ser_path);
985 let mut de_path = path;
986 de_path
987 .path
988 .segments
989 .push(Ident::new("deserialize", Span::call_site()).into());
990 deserialize_with.set(&m.path, de_path);
991 }
992 }
993
994 // Parse `#[serde(serialize_with = "...")]`
995 Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
996 if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
997 serialize_with.set(&m.path, path);
998 }
999 }
1000
1001 // Parse `#[serde(deserialize_with = "...")]`
1002 Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
1003 if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
1004 deserialize_with.set(&m.path, path);
1005 }
1006 }
1007
1008 // Defer `#[serde(borrow)]` and `#[serde(borrow = "'a + 'b")]`
1009 Meta(m) if m.path() == BORROW => match &variant.fields {
1010 syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
1011 borrow.set(m.path(), m.clone());
1012 }
1013 _ => {
1014 cx.error_spanned_by(
1015 variant,
1016 "#[serde(borrow)] may only be used on newtype variants",
1017 );
1018 }
1019 },
1020
1021 Meta(meta_item) => {
1022 let path = meta_item
1023 .path()
1024 .into_token_stream()
1025 .to_string()
1026 .replace(' ', "");
1027 cx.error_spanned_by(
1028 meta_item.path(),
1029 format!("unknown serde variant attribute `{}`", path),
1030 );
1031 }
1032
1033 Lit(lit) => {
1034 cx.error_spanned_by(lit, "unexpected literal in serde variant attribute");
1035 }
1036 }
1037 }
1038
1039 Variant {
1040 name: Name::from_attrs(unraw(&variant.ident), ser_name, de_name, Some(de_aliases)),
1041 rename_all_rules: RenameAllRules {
1042 serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
1043 deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
1044 },
1045 ser_bound: ser_bound.get(),
1046 de_bound: de_bound.get(),
1047 skip_deserializing: skip_deserializing.get(),
1048 skip_serializing: skip_serializing.get(),
1049 other: other.get(),
1050 serialize_with: serialize_with.get(),
1051 deserialize_with: deserialize_with.get(),
1052 borrow: borrow.get(),
1053 }
1054 }
1055
name(&self) -> &Name1056 pub fn name(&self) -> &Name {
1057 &self.name
1058 }
1059
aliases(&self) -> Vec<String>1060 pub fn aliases(&self) -> Vec<String> {
1061 self.name.deserialize_aliases()
1062 }
1063
rename_by_rules(&mut self, rules: &RenameAllRules)1064 pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
1065 if !self.name.serialize_renamed {
1066 self.name.serialize = rules.serialize.apply_to_variant(&self.name.serialize);
1067 }
1068 if !self.name.deserialize_renamed {
1069 self.name.deserialize = rules.deserialize.apply_to_variant(&self.name.deserialize);
1070 }
1071 }
1072
rename_all_rules(&self) -> &RenameAllRules1073 pub fn rename_all_rules(&self) -> &RenameAllRules {
1074 &self.rename_all_rules
1075 }
1076
ser_bound(&self) -> Option<&[syn::WherePredicate]>1077 pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
1078 self.ser_bound.as_ref().map(|vec| &vec[..])
1079 }
1080
de_bound(&self) -> Option<&[syn::WherePredicate]>1081 pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
1082 self.de_bound.as_ref().map(|vec| &vec[..])
1083 }
1084
skip_deserializing(&self) -> bool1085 pub fn skip_deserializing(&self) -> bool {
1086 self.skip_deserializing
1087 }
1088
skip_serializing(&self) -> bool1089 pub fn skip_serializing(&self) -> bool {
1090 self.skip_serializing
1091 }
1092
other(&self) -> bool1093 pub fn other(&self) -> bool {
1094 self.other
1095 }
1096
serialize_with(&self) -> Option<&syn::ExprPath>1097 pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
1098 self.serialize_with.as_ref()
1099 }
1100
deserialize_with(&self) -> Option<&syn::ExprPath>1101 pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
1102 self.deserialize_with.as_ref()
1103 }
1104 }
1105
1106 /// Represents field attribute information
1107 pub struct Field {
1108 name: Name,
1109 skip_serializing: bool,
1110 skip_deserializing: bool,
1111 skip_serializing_if: Option<syn::ExprPath>,
1112 default: Default,
1113 serialize_with: Option<syn::ExprPath>,
1114 deserialize_with: Option<syn::ExprPath>,
1115 ser_bound: Option<Vec<syn::WherePredicate>>,
1116 de_bound: Option<Vec<syn::WherePredicate>>,
1117 borrowed_lifetimes: BTreeSet<syn::Lifetime>,
1118 getter: Option<syn::ExprPath>,
1119 flatten: bool,
1120 transparent: bool,
1121 }
1122
1123 /// Represents the default to use for a field when deserializing.
1124 pub enum Default {
1125 /// Field must always be specified because it does not have a default.
1126 None,
1127 /// The default is given by `std::default::Default::default()`.
1128 Default,
1129 /// The default is given by this function.
1130 Path(syn::ExprPath),
1131 }
1132
1133 impl Default {
is_none(&self) -> bool1134 pub fn is_none(&self) -> bool {
1135 match self {
1136 Default::None => true,
1137 Default::Default | Default::Path(_) => false,
1138 }
1139 }
1140 }
1141
1142 impl Field {
1143 /// Extract out the `#[serde(...)]` attributes from a struct field.
from_ast( cx: &Ctxt, index: usize, field: &syn::Field, attrs: Option<&Variant>, container_default: &Default, ) -> Self1144 pub fn from_ast(
1145 cx: &Ctxt,
1146 index: usize,
1147 field: &syn::Field,
1148 attrs: Option<&Variant>,
1149 container_default: &Default,
1150 ) -> Self {
1151 let mut ser_name = Attr::none(cx, RENAME);
1152 let mut de_name = Attr::none(cx, RENAME);
1153 let mut de_aliases = VecAttr::none(cx, RENAME);
1154 let mut skip_serializing = BoolAttr::none(cx, SKIP_SERIALIZING);
1155 let mut skip_deserializing = BoolAttr::none(cx, SKIP_DESERIALIZING);
1156 let mut skip_serializing_if = Attr::none(cx, SKIP_SERIALIZING_IF);
1157 let mut default = Attr::none(cx, DEFAULT);
1158 let mut serialize_with = Attr::none(cx, SERIALIZE_WITH);
1159 let mut deserialize_with = Attr::none(cx, DESERIALIZE_WITH);
1160 let mut ser_bound = Attr::none(cx, BOUND);
1161 let mut de_bound = Attr::none(cx, BOUND);
1162 let mut borrowed_lifetimes = Attr::none(cx, BORROW);
1163 let mut getter = Attr::none(cx, GETTER);
1164 let mut flatten = BoolAttr::none(cx, FLATTEN);
1165
1166 let ident = match &field.ident {
1167 Some(ident) => unraw(ident),
1168 None => index.to_string(),
1169 };
1170
1171 let variant_borrow = attrs
1172 .and_then(|variant| variant.borrow.as_ref())
1173 .map(|borrow| Meta(borrow.clone()));
1174
1175 for meta_item in field
1176 .attrs
1177 .iter()
1178 .flat_map(|attr| get_serde_meta_items(cx, attr))
1179 .flatten()
1180 .chain(variant_borrow)
1181 {
1182 match &meta_item {
1183 // Parse `#[serde(rename = "foo")]`
1184 Meta(NameValue(m)) if m.path == RENAME => {
1185 if let Ok(s) = get_lit_str(cx, RENAME, &m.lit) {
1186 ser_name.set(&m.path, s.value());
1187 de_name.set_if_none(s.value());
1188 de_aliases.insert(&m.path, s.value());
1189 }
1190 }
1191
1192 // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
1193 Meta(List(m)) if m.path == RENAME => {
1194 if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
1195 ser_name.set_opt(&m.path, ser.map(syn::LitStr::value));
1196 for de_value in de {
1197 de_name.set_if_none(de_value.value());
1198 de_aliases.insert(&m.path, de_value.value());
1199 }
1200 }
1201 }
1202
1203 // Parse `#[serde(alias = "foo")]`
1204 Meta(NameValue(m)) if m.path == ALIAS => {
1205 if let Ok(s) = get_lit_str(cx, ALIAS, &m.lit) {
1206 de_aliases.insert(&m.path, s.value());
1207 }
1208 }
1209
1210 // Parse `#[serde(default)]`
1211 Meta(Path(word)) if word == DEFAULT => {
1212 default.set(word, Default::Default);
1213 }
1214
1215 // Parse `#[serde(default = "...")]`
1216 Meta(NameValue(m)) if m.path == DEFAULT => {
1217 if let Ok(path) = parse_lit_into_expr_path(cx, DEFAULT, &m.lit) {
1218 default.set(&m.path, Default::Path(path));
1219 }
1220 }
1221
1222 // Parse `#[serde(skip_serializing)]`
1223 Meta(Path(word)) if word == SKIP_SERIALIZING => {
1224 skip_serializing.set_true(word);
1225 }
1226
1227 // Parse `#[serde(skip_deserializing)]`
1228 Meta(Path(word)) if word == SKIP_DESERIALIZING => {
1229 skip_deserializing.set_true(word);
1230 }
1231
1232 // Parse `#[serde(skip)]`
1233 Meta(Path(word)) if word == SKIP => {
1234 skip_serializing.set_true(word);
1235 skip_deserializing.set_true(word);
1236 }
1237
1238 // Parse `#[serde(skip_serializing_if = "...")]`
1239 Meta(NameValue(m)) if m.path == SKIP_SERIALIZING_IF => {
1240 if let Ok(path) = parse_lit_into_expr_path(cx, SKIP_SERIALIZING_IF, &m.lit) {
1241 skip_serializing_if.set(&m.path, path);
1242 }
1243 }
1244
1245 // Parse `#[serde(serialize_with = "...")]`
1246 Meta(NameValue(m)) if m.path == SERIALIZE_WITH => {
1247 if let Ok(path) = parse_lit_into_expr_path(cx, SERIALIZE_WITH, &m.lit) {
1248 serialize_with.set(&m.path, path);
1249 }
1250 }
1251
1252 // Parse `#[serde(deserialize_with = "...")]`
1253 Meta(NameValue(m)) if m.path == DESERIALIZE_WITH => {
1254 if let Ok(path) = parse_lit_into_expr_path(cx, DESERIALIZE_WITH, &m.lit) {
1255 deserialize_with.set(&m.path, path);
1256 }
1257 }
1258
1259 // Parse `#[serde(with = "...")]`
1260 Meta(NameValue(m)) if m.path == WITH => {
1261 if let Ok(path) = parse_lit_into_expr_path(cx, WITH, &m.lit) {
1262 let mut ser_path = path.clone();
1263 ser_path
1264 .path
1265 .segments
1266 .push(Ident::new("serialize", Span::call_site()).into());
1267 serialize_with.set(&m.path, ser_path);
1268 let mut de_path = path;
1269 de_path
1270 .path
1271 .segments
1272 .push(Ident::new("deserialize", Span::call_site()).into());
1273 deserialize_with.set(&m.path, de_path);
1274 }
1275 }
1276
1277 // Parse `#[serde(bound = "T: SomeBound")]`
1278 Meta(NameValue(m)) if m.path == BOUND => {
1279 if let Ok(where_predicates) = parse_lit_into_where(cx, BOUND, BOUND, &m.lit) {
1280 ser_bound.set(&m.path, where_predicates.clone());
1281 de_bound.set(&m.path, where_predicates);
1282 }
1283 }
1284
1285 // Parse `#[serde(bound(serialize = "...", deserialize = "..."))]`
1286 Meta(List(m)) if m.path == BOUND => {
1287 if let Ok((ser, de)) = get_where_predicates(cx, &m.nested) {
1288 ser_bound.set_opt(&m.path, ser);
1289 de_bound.set_opt(&m.path, de);
1290 }
1291 }
1292
1293 // Parse `#[serde(borrow)]`
1294 Meta(Path(word)) if word == BORROW => {
1295 if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
1296 borrowed_lifetimes.set(word, borrowable);
1297 }
1298 }
1299
1300 // Parse `#[serde(borrow = "'a + 'b")]`
1301 Meta(NameValue(m)) if m.path == BORROW => {
1302 if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, BORROW, &m.lit) {
1303 if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, field) {
1304 for lifetime in &lifetimes {
1305 if !borrowable.contains(lifetime) {
1306 cx.error_spanned_by(
1307 field,
1308 format!(
1309 "field `{}` does not have lifetime {}",
1310 ident, lifetime
1311 ),
1312 );
1313 }
1314 }
1315 borrowed_lifetimes.set(&m.path, lifetimes);
1316 }
1317 }
1318 }
1319
1320 // Parse `#[serde(getter = "...")]`
1321 Meta(NameValue(m)) if m.path == GETTER => {
1322 if let Ok(path) = parse_lit_into_expr_path(cx, GETTER, &m.lit) {
1323 getter.set(&m.path, path);
1324 }
1325 }
1326
1327 // Parse `#[serde(flatten)]`
1328 Meta(Path(word)) if word == FLATTEN => {
1329 flatten.set_true(word);
1330 }
1331
1332 Meta(meta_item) => {
1333 let path = meta_item
1334 .path()
1335 .into_token_stream()
1336 .to_string()
1337 .replace(' ', "");
1338 cx.error_spanned_by(
1339 meta_item.path(),
1340 format!("unknown serde field attribute `{}`", path),
1341 );
1342 }
1343
1344 Lit(lit) => {
1345 cx.error_spanned_by(lit, "unexpected literal in serde field attribute");
1346 }
1347 }
1348 }
1349
1350 // Is skip_deserializing, initialize the field to Default::default() unless a
1351 // different default is specified by `#[serde(default = "...")]` on
1352 // ourselves or our container (e.g. the struct we are in).
1353 if let Default::None = *container_default {
1354 if skip_deserializing.0.value.is_some() {
1355 default.set_if_none(Default::Default);
1356 }
1357 }
1358
1359 let mut borrowed_lifetimes = borrowed_lifetimes.get().unwrap_or_default();
1360 if !borrowed_lifetimes.is_empty() {
1361 // Cow<str> and Cow<[u8]> never borrow by default:
1362 //
1363 // impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
1364 //
1365 // A #[serde(borrow)] attribute enables borrowing that corresponds
1366 // roughly to these impls:
1367 //
1368 // impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, str>
1369 // impl<'de: 'a, 'a> Deserialize<'de> for Cow<'a, [u8]>
1370 if is_cow(&field.ty, is_str) {
1371 let mut path = syn::Path {
1372 leading_colon: None,
1373 segments: Punctuated::new(),
1374 };
1375 let span = Span::call_site();
1376 path.segments.push(Ident::new("_serde", span).into());
1377 path.segments.push(Ident::new("__private", span).into());
1378 path.segments.push(Ident::new("de", span).into());
1379 path.segments
1380 .push(Ident::new("borrow_cow_str", span).into());
1381 let expr = syn::ExprPath {
1382 attrs: Vec::new(),
1383 qself: None,
1384 path,
1385 };
1386 deserialize_with.set_if_none(expr);
1387 } else if is_cow(&field.ty, is_slice_u8) {
1388 let mut path = syn::Path {
1389 leading_colon: None,
1390 segments: Punctuated::new(),
1391 };
1392 let span = Span::call_site();
1393 path.segments.push(Ident::new("_serde", span).into());
1394 path.segments.push(Ident::new("__private", span).into());
1395 path.segments.push(Ident::new("de", span).into());
1396 path.segments
1397 .push(Ident::new("borrow_cow_bytes", span).into());
1398 let expr = syn::ExprPath {
1399 attrs: Vec::new(),
1400 qself: None,
1401 path,
1402 };
1403 deserialize_with.set_if_none(expr);
1404 }
1405 } else if is_implicitly_borrowed(&field.ty) {
1406 // Types &str and &[u8] are always implicitly borrowed. No need for
1407 // a #[serde(borrow)].
1408 collect_lifetimes(&field.ty, &mut borrowed_lifetimes);
1409 }
1410
1411 Field {
1412 name: Name::from_attrs(ident, ser_name, de_name, Some(de_aliases)),
1413 skip_serializing: skip_serializing.get(),
1414 skip_deserializing: skip_deserializing.get(),
1415 skip_serializing_if: skip_serializing_if.get(),
1416 default: default.get().unwrap_or(Default::None),
1417 serialize_with: serialize_with.get(),
1418 deserialize_with: deserialize_with.get(),
1419 ser_bound: ser_bound.get(),
1420 de_bound: de_bound.get(),
1421 borrowed_lifetimes,
1422 getter: getter.get(),
1423 flatten: flatten.get(),
1424 transparent: false,
1425 }
1426 }
1427
name(&self) -> &Name1428 pub fn name(&self) -> &Name {
1429 &self.name
1430 }
1431
aliases(&self) -> Vec<String>1432 pub fn aliases(&self) -> Vec<String> {
1433 self.name.deserialize_aliases()
1434 }
1435
rename_by_rules(&mut self, rules: &RenameAllRules)1436 pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
1437 if !self.name.serialize_renamed {
1438 self.name.serialize = rules.serialize.apply_to_field(&self.name.serialize);
1439 }
1440 if !self.name.deserialize_renamed {
1441 self.name.deserialize = rules.deserialize.apply_to_field(&self.name.deserialize);
1442 }
1443 }
1444
skip_serializing(&self) -> bool1445 pub fn skip_serializing(&self) -> bool {
1446 self.skip_serializing
1447 }
1448
skip_deserializing(&self) -> bool1449 pub fn skip_deserializing(&self) -> bool {
1450 self.skip_deserializing
1451 }
1452
skip_serializing_if(&self) -> Option<&syn::ExprPath>1453 pub fn skip_serializing_if(&self) -> Option<&syn::ExprPath> {
1454 self.skip_serializing_if.as_ref()
1455 }
1456
default(&self) -> &Default1457 pub fn default(&self) -> &Default {
1458 &self.default
1459 }
1460
serialize_with(&self) -> Option<&syn::ExprPath>1461 pub fn serialize_with(&self) -> Option<&syn::ExprPath> {
1462 self.serialize_with.as_ref()
1463 }
1464
deserialize_with(&self) -> Option<&syn::ExprPath>1465 pub fn deserialize_with(&self) -> Option<&syn::ExprPath> {
1466 self.deserialize_with.as_ref()
1467 }
1468
ser_bound(&self) -> Option<&[syn::WherePredicate]>1469 pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
1470 self.ser_bound.as_ref().map(|vec| &vec[..])
1471 }
1472
de_bound(&self) -> Option<&[syn::WherePredicate]>1473 pub fn de_bound(&self) -> Option<&[syn::WherePredicate]> {
1474 self.de_bound.as_ref().map(|vec| &vec[..])
1475 }
1476
borrowed_lifetimes(&self) -> &BTreeSet<syn::Lifetime>1477 pub fn borrowed_lifetimes(&self) -> &BTreeSet<syn::Lifetime> {
1478 &self.borrowed_lifetimes
1479 }
1480
getter(&self) -> Option<&syn::ExprPath>1481 pub fn getter(&self) -> Option<&syn::ExprPath> {
1482 self.getter.as_ref()
1483 }
1484
flatten(&self) -> bool1485 pub fn flatten(&self) -> bool {
1486 self.flatten
1487 }
1488
transparent(&self) -> bool1489 pub fn transparent(&self) -> bool {
1490 self.transparent
1491 }
1492
mark_transparent(&mut self)1493 pub fn mark_transparent(&mut self) {
1494 self.transparent = true;
1495 }
1496 }
1497
1498 type SerAndDe<T> = (Option<T>, Option<T>);
1499
get_ser_and_de<'a, 'b, T, F>( cx: &'b Ctxt, attr_name: Symbol, metas: &'a Punctuated<syn::NestedMeta, Token![,]>, f: F, ) -> Result<(VecAttr<'b, T>, VecAttr<'b, T>), ()> where T: 'a, F: Fn(&Ctxt, Symbol, Symbol, &'a syn::Lit) -> Result<T, ()>,1500 fn get_ser_and_de<'a, 'b, T, F>(
1501 cx: &'b Ctxt,
1502 attr_name: Symbol,
1503 metas: &'a Punctuated<syn::NestedMeta, Token![,]>,
1504 f: F,
1505 ) -> Result<(VecAttr<'b, T>, VecAttr<'b, T>), ()>
1506 where
1507 T: 'a,
1508 F: Fn(&Ctxt, Symbol, Symbol, &'a syn::Lit) -> Result<T, ()>,
1509 {
1510 let mut ser_meta = VecAttr::none(cx, attr_name);
1511 let mut de_meta = VecAttr::none(cx, attr_name);
1512
1513 for meta in metas {
1514 match meta {
1515 Meta(NameValue(meta)) if meta.path == SERIALIZE => {
1516 if let Ok(v) = f(cx, attr_name, SERIALIZE, &meta.lit) {
1517 ser_meta.insert(&meta.path, v);
1518 }
1519 }
1520
1521 Meta(NameValue(meta)) if meta.path == DESERIALIZE => {
1522 if let Ok(v) = f(cx, attr_name, DESERIALIZE, &meta.lit) {
1523 de_meta.insert(&meta.path, v);
1524 }
1525 }
1526
1527 _ => {
1528 cx.error_spanned_by(
1529 meta,
1530 format!(
1531 "malformed {0} attribute, expected `{0}(serialize = ..., deserialize = ...)`",
1532 attr_name
1533 ),
1534 );
1535 return Err(());
1536 }
1537 }
1538 }
1539
1540 Ok((ser_meta, de_meta))
1541 }
1542
get_renames<'a>( cx: &Ctxt, items: &'a Punctuated<syn::NestedMeta, Token![,]>, ) -> Result<SerAndDe<&'a syn::LitStr>, ()>1543 fn get_renames<'a>(
1544 cx: &Ctxt,
1545 items: &'a Punctuated<syn::NestedMeta, Token![,]>,
1546 ) -> Result<SerAndDe<&'a syn::LitStr>, ()> {
1547 let (ser, de) = get_ser_and_de(cx, RENAME, items, get_lit_str2)?;
1548 Ok((ser.at_most_one()?, de.at_most_one()?))
1549 }
1550
get_multiple_renames<'a>( cx: &Ctxt, items: &'a Punctuated<syn::NestedMeta, Token![,]>, ) -> Result<(Option<&'a syn::LitStr>, Vec<&'a syn::LitStr>), ()>1551 fn get_multiple_renames<'a>(
1552 cx: &Ctxt,
1553 items: &'a Punctuated<syn::NestedMeta, Token![,]>,
1554 ) -> Result<(Option<&'a syn::LitStr>, Vec<&'a syn::LitStr>), ()> {
1555 let (ser, de) = get_ser_and_de(cx, RENAME, items, get_lit_str2)?;
1556 Ok((ser.at_most_one()?, de.get()))
1557 }
1558
get_where_predicates( cx: &Ctxt, items: &Punctuated<syn::NestedMeta, Token![,]>, ) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()>1559 fn get_where_predicates(
1560 cx: &Ctxt,
1561 items: &Punctuated<syn::NestedMeta, Token![,]>,
1562 ) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()> {
1563 let (ser, de) = get_ser_and_de(cx, BOUND, items, parse_lit_into_where)?;
1564 Ok((ser.at_most_one()?, de.at_most_one()?))
1565 }
1566
get_serde_meta_items(cx: &Ctxt, attr: &syn::Attribute) -> Result<Vec<syn::NestedMeta>, ()>1567 pub fn get_serde_meta_items(cx: &Ctxt, attr: &syn::Attribute) -> Result<Vec<syn::NestedMeta>, ()> {
1568 if attr.path != SERDE {
1569 return Ok(Vec::new());
1570 }
1571
1572 match attr.parse_meta() {
1573 Ok(List(meta)) => Ok(meta.nested.into_iter().collect()),
1574 Ok(other) => {
1575 cx.error_spanned_by(other, "expected #[serde(...)]");
1576 Err(())
1577 }
1578 Err(err) => {
1579 cx.syn_error(err);
1580 Err(())
1581 }
1582 }
1583 }
1584
get_lit_str<'a>(cx: &Ctxt, attr_name: Symbol, lit: &'a syn::Lit) -> Result<&'a syn::LitStr, ()>1585 fn get_lit_str<'a>(cx: &Ctxt, attr_name: Symbol, lit: &'a syn::Lit) -> Result<&'a syn::LitStr, ()> {
1586 get_lit_str2(cx, attr_name, attr_name, lit)
1587 }
1588
get_lit_str2<'a>( cx: &Ctxt, attr_name: Symbol, meta_item_name: Symbol, lit: &'a syn::Lit, ) -> Result<&'a syn::LitStr, ()>1589 fn get_lit_str2<'a>(
1590 cx: &Ctxt,
1591 attr_name: Symbol,
1592 meta_item_name: Symbol,
1593 lit: &'a syn::Lit,
1594 ) -> Result<&'a syn::LitStr, ()> {
1595 if let syn::Lit::Str(lit) = lit {
1596 Ok(lit)
1597 } else {
1598 cx.error_spanned_by(
1599 lit,
1600 format!(
1601 "expected serde {} attribute to be a string: `{} = \"...\"`",
1602 attr_name, meta_item_name
1603 ),
1604 );
1605 Err(())
1606 }
1607 }
1608
parse_lit_into_path(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Path, ()>1609 fn parse_lit_into_path(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Path, ()> {
1610 let string = get_lit_str(cx, attr_name, lit)?;
1611 parse_lit_str(string).map_err(|_| {
1612 cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
1613 })
1614 }
1615
parse_lit_into_expr_path( cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit, ) -> Result<syn::ExprPath, ()>1616 fn parse_lit_into_expr_path(
1617 cx: &Ctxt,
1618 attr_name: Symbol,
1619 lit: &syn::Lit,
1620 ) -> Result<syn::ExprPath, ()> {
1621 let string = get_lit_str(cx, attr_name, lit)?;
1622 parse_lit_str(string).map_err(|_| {
1623 cx.error_spanned_by(lit, format!("failed to parse path: {:?}", string.value()));
1624 })
1625 }
1626
parse_lit_into_where( cx: &Ctxt, attr_name: Symbol, meta_item_name: Symbol, lit: &syn::Lit, ) -> Result<Vec<syn::WherePredicate>, ()>1627 fn parse_lit_into_where(
1628 cx: &Ctxt,
1629 attr_name: Symbol,
1630 meta_item_name: Symbol,
1631 lit: &syn::Lit,
1632 ) -> Result<Vec<syn::WherePredicate>, ()> {
1633 let string = get_lit_str2(cx, attr_name, meta_item_name, lit)?;
1634 if string.value().is_empty() {
1635 return Ok(Vec::new());
1636 }
1637
1638 let where_string = syn::LitStr::new(&format!("where {}", string.value()), string.span());
1639
1640 parse_lit_str::<syn::WhereClause>(&where_string)
1641 .map(|wh| wh.predicates.into_iter().collect())
1642 .map_err(|err| cx.error_spanned_by(lit, err))
1643 }
1644
parse_lit_into_ty(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Type, ()>1645 fn parse_lit_into_ty(cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit) -> Result<syn::Type, ()> {
1646 let string = get_lit_str(cx, attr_name, lit)?;
1647
1648 parse_lit_str(string).map_err(|_| {
1649 cx.error_spanned_by(
1650 lit,
1651 format!("failed to parse type: {} = {:?}", attr_name, string.value()),
1652 );
1653 })
1654 }
1655
1656 // Parses a string literal like "'a + 'b + 'c" containing a nonempty list of
1657 // lifetimes separated by `+`.
parse_lit_into_lifetimes( cx: &Ctxt, attr_name: Symbol, lit: &syn::Lit, ) -> Result<BTreeSet<syn::Lifetime>, ()>1658 fn parse_lit_into_lifetimes(
1659 cx: &Ctxt,
1660 attr_name: Symbol,
1661 lit: &syn::Lit,
1662 ) -> Result<BTreeSet<syn::Lifetime>, ()> {
1663 let string = get_lit_str(cx, attr_name, lit)?;
1664 if string.value().is_empty() {
1665 cx.error_spanned_by(lit, "at least one lifetime must be borrowed");
1666 return Err(());
1667 }
1668
1669 struct BorrowedLifetimes(Punctuated<syn::Lifetime, Token![+]>);
1670
1671 impl Parse for BorrowedLifetimes {
1672 fn parse(input: ParseStream) -> parse::Result<Self> {
1673 Punctuated::parse_separated_nonempty(input).map(BorrowedLifetimes)
1674 }
1675 }
1676
1677 if let Ok(BorrowedLifetimes(lifetimes)) = parse_lit_str(string) {
1678 let mut set = BTreeSet::new();
1679 for lifetime in lifetimes {
1680 if !set.insert(lifetime.clone()) {
1681 cx.error_spanned_by(lit, format!("duplicate borrowed lifetime `{}`", lifetime));
1682 }
1683 }
1684 return Ok(set);
1685 }
1686
1687 cx.error_spanned_by(
1688 lit,
1689 format!("failed to parse borrowed lifetimes: {:?}", string.value()),
1690 );
1691 Err(())
1692 }
1693
is_implicitly_borrowed(ty: &syn::Type) -> bool1694 fn is_implicitly_borrowed(ty: &syn::Type) -> bool {
1695 is_implicitly_borrowed_reference(ty) || is_option(ty, is_implicitly_borrowed_reference)
1696 }
1697
is_implicitly_borrowed_reference(ty: &syn::Type) -> bool1698 fn is_implicitly_borrowed_reference(ty: &syn::Type) -> bool {
1699 is_reference(ty, is_str) || is_reference(ty, is_slice_u8)
1700 }
1701
1702 // Whether the type looks like it might be `std::borrow::Cow<T>` where elem="T".
1703 // This can have false negatives and false positives.
1704 //
1705 // False negative:
1706 //
1707 // use std::borrow::Cow as Pig;
1708 //
1709 // #[derive(Deserialize)]
1710 // struct S<'a> {
1711 // #[serde(borrow)]
1712 // pig: Pig<'a, str>,
1713 // }
1714 //
1715 // False positive:
1716 //
1717 // type str = [i16];
1718 //
1719 // #[derive(Deserialize)]
1720 // struct S<'a> {
1721 // #[serde(borrow)]
1722 // cow: Cow<'a, str>,
1723 // }
is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool1724 fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
1725 let path = match ungroup(ty) {
1726 syn::Type::Path(ty) => &ty.path,
1727 _ => {
1728 return false;
1729 }
1730 };
1731 let seg = match path.segments.last() {
1732 Some(seg) => seg,
1733 None => {
1734 return false;
1735 }
1736 };
1737 let args = match &seg.arguments {
1738 syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
1739 _ => {
1740 return false;
1741 }
1742 };
1743 seg.ident == "Cow"
1744 && args.len() == 2
1745 && match (&args[0], &args[1]) {
1746 (syn::GenericArgument::Lifetime(_), syn::GenericArgument::Type(arg)) => elem(arg),
1747 _ => false,
1748 }
1749 }
1750
is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool1751 fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
1752 let path = match ungroup(ty) {
1753 syn::Type::Path(ty) => &ty.path,
1754 _ => {
1755 return false;
1756 }
1757 };
1758 let seg = match path.segments.last() {
1759 Some(seg) => seg,
1760 None => {
1761 return false;
1762 }
1763 };
1764 let args = match &seg.arguments {
1765 syn::PathArguments::AngleBracketed(bracketed) => &bracketed.args,
1766 _ => {
1767 return false;
1768 }
1769 };
1770 seg.ident == "Option"
1771 && args.len() == 1
1772 && match &args[0] {
1773 syn::GenericArgument::Type(arg) => elem(arg),
1774 _ => false,
1775 }
1776 }
1777
1778 // Whether the type looks like it might be `&T` where elem="T". This can have
1779 // false negatives and false positives.
1780 //
1781 // False negative:
1782 //
1783 // type Yarn = str;
1784 //
1785 // #[derive(Deserialize)]
1786 // struct S<'a> {
1787 // r: &'a Yarn,
1788 // }
1789 //
1790 // False positive:
1791 //
1792 // type str = [i16];
1793 //
1794 // #[derive(Deserialize)]
1795 // struct S<'a> {
1796 // r: &'a str,
1797 // }
is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool1798 fn is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
1799 match ungroup(ty) {
1800 syn::Type::Reference(ty) => ty.mutability.is_none() && elem(&ty.elem),
1801 _ => false,
1802 }
1803 }
1804
is_str(ty: &syn::Type) -> bool1805 fn is_str(ty: &syn::Type) -> bool {
1806 is_primitive_type(ty, "str")
1807 }
1808
is_slice_u8(ty: &syn::Type) -> bool1809 fn is_slice_u8(ty: &syn::Type) -> bool {
1810 match ungroup(ty) {
1811 syn::Type::Slice(ty) => is_primitive_type(&ty.elem, "u8"),
1812 _ => false,
1813 }
1814 }
1815
is_primitive_type(ty: &syn::Type, primitive: &str) -> bool1816 fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
1817 match ungroup(ty) {
1818 syn::Type::Path(ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
1819 _ => false,
1820 }
1821 }
1822
is_primitive_path(path: &syn::Path, primitive: &str) -> bool1823 fn is_primitive_path(path: &syn::Path, primitive: &str) -> bool {
1824 path.leading_colon.is_none()
1825 && path.segments.len() == 1
1826 && path.segments[0].ident == primitive
1827 && path.segments[0].arguments.is_empty()
1828 }
1829
1830 // All lifetimes that this type could borrow from a Deserializer.
1831 //
1832 // For example a type `S<'a, 'b>` could borrow `'a` and `'b`. On the other hand
1833 // a type `for<'a> fn(&'a str)` could not borrow `'a` from the Deserializer.
1834 //
1835 // This is used when there is an explicit or implicit `#[serde(borrow)]`
1836 // attribute on the field so there must be at least one borrowable lifetime.
borrowable_lifetimes( cx: &Ctxt, name: &str, field: &syn::Field, ) -> Result<BTreeSet<syn::Lifetime>, ()>1837 fn borrowable_lifetimes(
1838 cx: &Ctxt,
1839 name: &str,
1840 field: &syn::Field,
1841 ) -> Result<BTreeSet<syn::Lifetime>, ()> {
1842 let mut lifetimes = BTreeSet::new();
1843 collect_lifetimes(&field.ty, &mut lifetimes);
1844 if lifetimes.is_empty() {
1845 cx.error_spanned_by(
1846 field,
1847 format!("field `{}` has no lifetimes to borrow", name),
1848 );
1849 Err(())
1850 } else {
1851 Ok(lifetimes)
1852 }
1853 }
1854
collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>)1855 fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
1856 match ty {
1857 syn::Type::Slice(ty) => {
1858 collect_lifetimes(&ty.elem, out);
1859 }
1860 syn::Type::Array(ty) => {
1861 collect_lifetimes(&ty.elem, out);
1862 }
1863 syn::Type::Ptr(ty) => {
1864 collect_lifetimes(&ty.elem, out);
1865 }
1866 syn::Type::Reference(ty) => {
1867 out.extend(ty.lifetime.iter().cloned());
1868 collect_lifetimes(&ty.elem, out);
1869 }
1870 syn::Type::Tuple(ty) => {
1871 for elem in &ty.elems {
1872 collect_lifetimes(elem, out);
1873 }
1874 }
1875 syn::Type::Path(ty) => {
1876 if let Some(qself) = &ty.qself {
1877 collect_lifetimes(&qself.ty, out);
1878 }
1879 for seg in &ty.path.segments {
1880 if let syn::PathArguments::AngleBracketed(bracketed) = &seg.arguments {
1881 for arg in &bracketed.args {
1882 match arg {
1883 syn::GenericArgument::Lifetime(lifetime) => {
1884 out.insert(lifetime.clone());
1885 }
1886 syn::GenericArgument::Type(ty) => {
1887 collect_lifetimes(ty, out);
1888 }
1889 syn::GenericArgument::Binding(binding) => {
1890 collect_lifetimes(&binding.ty, out);
1891 }
1892 syn::GenericArgument::Constraint(_)
1893 | syn::GenericArgument::Const(_) => {}
1894 }
1895 }
1896 }
1897 }
1898 }
1899 syn::Type::Paren(ty) => {
1900 collect_lifetimes(&ty.elem, out);
1901 }
1902 syn::Type::Group(ty) => {
1903 collect_lifetimes(&ty.elem, out);
1904 }
1905 syn::Type::Macro(ty) => {
1906 collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
1907 }
1908 syn::Type::BareFn(_)
1909 | syn::Type::Never(_)
1910 | syn::Type::TraitObject(_)
1911 | syn::Type::ImplTrait(_)
1912 | syn::Type::Infer(_)
1913 | syn::Type::Verbatim(_) => {}
1914
1915 #[cfg(test)]
1916 syn::Type::__TestExhaustive(_) => unimplemented!(),
1917 #[cfg(not(test))]
1918 _ => {}
1919 }
1920 }
1921
collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>)1922 fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>) {
1923 let mut iter = tokens.into_iter();
1924 while let Some(tt) = iter.next() {
1925 match &tt {
1926 TokenTree::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
1927 if let Some(TokenTree::Ident(ident)) = iter.next() {
1928 out.insert(syn::Lifetime {
1929 apostrophe: op.span(),
1930 ident,
1931 });
1932 }
1933 }
1934 TokenTree::Group(group) => {
1935 let tokens = group.stream();
1936 collect_lifetimes_from_tokens(tokens, out);
1937 }
1938 _ => {}
1939 }
1940 }
1941 }
1942
parse_lit_str<T>(s: &syn::LitStr) -> parse::Result<T> where T: Parse,1943 fn parse_lit_str<T>(s: &syn::LitStr) -> parse::Result<T>
1944 where
1945 T: Parse,
1946 {
1947 let tokens = spanned_tokens(s)?;
1948 syn::parse2(tokens)
1949 }
1950
spanned_tokens(s: &syn::LitStr) -> parse::Result<TokenStream>1951 fn spanned_tokens(s: &syn::LitStr) -> parse::Result<TokenStream> {
1952 let stream = syn::parse_str(&s.value())?;
1953 Ok(respan(stream, s.span()))
1954 }
1955