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