xso_proc/
types.rs

1// Copyright (c) 2024 Jonas Schäfer <jonas@zombofant.net>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7//! Module with specific [`syn::Type`] constructors.
8
9use proc_macro2::Span;
10use syn::{spanned::Spanned, *};
11
12/// Construct a [`syn::Type`] referring to `::xso::exports::rxml::Namespace`.
13pub(crate) fn namespace_ty(span: Span) -> Type {
14    Type::Path(TypePath {
15        qself: None,
16        path: Path {
17            leading_colon: Some(syn::token::PathSep {
18                spans: [span, span],
19            }),
20            segments: [
21                PathSegment {
22                    ident: Ident::new("xso", span),
23                    arguments: PathArguments::None,
24                },
25                PathSegment {
26                    ident: Ident::new("exports", span),
27                    arguments: PathArguments::None,
28                },
29                PathSegment {
30                    ident: Ident::new("rxml", span),
31                    arguments: PathArguments::None,
32                },
33                PathSegment {
34                    ident: Ident::new("Namespace", span),
35                    arguments: PathArguments::None,
36                },
37            ]
38            .into_iter()
39            .collect(),
40        },
41    })
42}
43
44/// Construct a [`syn::Type`] referring to `::xso::exports::rxml::NcNameStr`.
45pub(crate) fn ncnamestr_ty(span: Span) -> Type {
46    Type::Path(TypePath {
47        qself: None,
48        path: Path {
49            leading_colon: Some(syn::token::PathSep {
50                spans: [span, span],
51            }),
52            segments: [
53                PathSegment {
54                    ident: Ident::new("xso", span),
55                    arguments: PathArguments::None,
56                },
57                PathSegment {
58                    ident: Ident::new("exports", span),
59                    arguments: PathArguments::None,
60                },
61                PathSegment {
62                    ident: Ident::new("rxml", span),
63                    arguments: PathArguments::None,
64                },
65                PathSegment {
66                    ident: Ident::new("NcNameStr", span),
67                    arguments: PathArguments::None,
68                },
69            ]
70            .into_iter()
71            .collect(),
72        },
73    })
74}
75
76/// Construct a [`syn::Type`] referring to `Cow<#lifetime, #ty>`.
77pub(crate) fn cow_ty(ty: Type, lifetime: Lifetime) -> Type {
78    let span = ty.span();
79    Type::Path(TypePath {
80        qself: None,
81        path: Path {
82            leading_colon: Some(syn::token::PathSep {
83                spans: [span, span],
84            }),
85            segments: [
86                PathSegment {
87                    ident: Ident::new("xso", span),
88                    arguments: PathArguments::None,
89                },
90                PathSegment {
91                    ident: Ident::new("exports", span),
92                    arguments: PathArguments::None,
93                },
94                PathSegment {
95                    ident: Ident::new("alloc", span),
96                    arguments: PathArguments::None,
97                },
98                PathSegment {
99                    ident: Ident::new("borrow", span),
100                    arguments: PathArguments::None,
101                },
102                PathSegment {
103                    ident: Ident::new("Cow", span),
104                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
105                        colon2_token: None,
106                        lt_token: token::Lt { spans: [span] },
107                        args: [
108                            GenericArgument::Lifetime(lifetime),
109                            GenericArgument::Type(ty),
110                        ]
111                        .into_iter()
112                        .collect(),
113                        gt_token: token::Gt { spans: [span] },
114                    }),
115                },
116            ]
117            .into_iter()
118            .collect(),
119        },
120    })
121}
122
123/// Construct a [`syn::Type`] referring to
124/// `Cow<#lifetime, ::rxml::NcNameStr>`.
125pub(crate) fn ncnamestr_cow_ty(ty_span: Span, lifetime: Lifetime) -> Type {
126    cow_ty(ncnamestr_ty(ty_span), lifetime)
127}
128
129/// Construct a [`syn::Expr`] referring to
130/// `<#ty as ::xso::FromXmlText>::from_xml_text`.
131pub(crate) fn from_xml_text_fn(ty: Type) -> Expr {
132    let span = ty.span();
133    Expr::Path(ExprPath {
134        attrs: Vec::new(),
135        qself: Some(QSelf {
136            lt_token: syn::token::Lt { spans: [span] },
137            ty: Box::new(ty),
138            position: 2,
139            as_token: Some(syn::token::As { span }),
140            gt_token: syn::token::Gt { spans: [span] },
141        }),
142        path: Path {
143            leading_colon: Some(syn::token::PathSep {
144                spans: [span, span],
145            }),
146            segments: [
147                PathSegment {
148                    ident: Ident::new("xso", span),
149                    arguments: PathArguments::None,
150                },
151                PathSegment {
152                    ident: Ident::new("FromXmlText", span),
153                    arguments: PathArguments::None,
154                },
155                PathSegment {
156                    ident: Ident::new("from_xml_text", span),
157                    arguments: PathArguments::None,
158                },
159            ]
160            .into_iter()
161            .collect(),
162        },
163    })
164}
165
166/// Construct a [`syn::Expr`] referring to
167/// `<#ty as ::xso::AsOptionalXmlText>::as_optional_xml_text`.
168pub(crate) fn as_optional_xml_text_fn(ty: Type) -> Expr {
169    let span = ty.span();
170    Expr::Path(ExprPath {
171        attrs: Vec::new(),
172        qself: Some(QSelf {
173            lt_token: syn::token::Lt { spans: [span] },
174            ty: Box::new(ty),
175            position: 2,
176            as_token: Some(syn::token::As { span }),
177            gt_token: syn::token::Gt { spans: [span] },
178        }),
179        path: Path {
180            leading_colon: Some(syn::token::PathSep {
181                spans: [span, span],
182            }),
183            segments: [
184                PathSegment {
185                    ident: Ident::new("xso", span),
186                    arguments: PathArguments::None,
187                },
188                PathSegment {
189                    ident: Ident::new("AsOptionalXmlText", span),
190                    arguments: PathArguments::None,
191                },
192                PathSegment {
193                    ident: Ident::new("as_optional_xml_text", span),
194                    arguments: PathArguments::None,
195                },
196            ]
197            .into_iter()
198            .collect(),
199        },
200    })
201}
202
203/// Construct a [`syn::Expr`] referring to
204/// `<#of_ty as ::core::default::Default>::default`.
205pub(crate) fn default_fn(of_ty: Type) -> Expr {
206    let span = of_ty.span();
207    Expr::Path(ExprPath {
208        attrs: Vec::new(),
209        qself: Some(QSelf {
210            lt_token: syn::token::Lt { spans: [span] },
211            ty: Box::new(of_ty),
212            position: 3,
213            as_token: Some(syn::token::As { span }),
214            gt_token: syn::token::Gt { spans: [span] },
215        }),
216        path: Path {
217            leading_colon: Some(syn::token::PathSep {
218                spans: [span, span],
219            }),
220            segments: [
221                PathSegment {
222                    ident: Ident::new("core", span),
223                    arguments: PathArguments::None,
224                },
225                PathSegment {
226                    ident: Ident::new("default", span),
227                    arguments: PathArguments::None,
228                },
229                PathSegment {
230                    ident: Ident::new("Default", span),
231                    arguments: PathArguments::None,
232                },
233                PathSegment {
234                    ident: Ident::new("default", span),
235                    arguments: PathArguments::None,
236                },
237            ]
238            .into_iter()
239            .collect(),
240        },
241    })
242}
243
244/// Construct a [`syn::Type`] referring to `::alloc::string::String`.
245pub(crate) fn string_ty(span: Span) -> Type {
246    Type::Path(TypePath {
247        qself: None,
248        path: Path {
249            leading_colon: Some(syn::token::PathSep {
250                spans: [span, span],
251            }),
252            segments: [
253                PathSegment {
254                    ident: Ident::new("xso", span),
255                    arguments: PathArguments::None,
256                },
257                PathSegment {
258                    ident: Ident::new("exports", span),
259                    arguments: PathArguments::None,
260                },
261                PathSegment {
262                    ident: Ident::new("alloc", span),
263                    arguments: PathArguments::None,
264                },
265                PathSegment {
266                    ident: Ident::new("string", span),
267                    arguments: PathArguments::None,
268                },
269                PathSegment {
270                    ident: Ident::new("String", span),
271                    arguments: PathArguments::None,
272                },
273            ]
274            .into_iter()
275            .collect(),
276        },
277    })
278}
279
280/// Construct a [`syn::Expr`] referring to
281/// `<#ty as ::xso::AsXmlText>::as_xml_text`.
282pub(crate) fn as_xml_text_fn(ty: Type) -> Expr {
283    let span = ty.span();
284    Expr::Path(ExprPath {
285        attrs: Vec::new(),
286        qself: Some(QSelf {
287            lt_token: syn::token::Lt { spans: [span] },
288            ty: Box::new(ty),
289            position: 2,
290            as_token: Some(syn::token::As { span }),
291            gt_token: syn::token::Gt { spans: [span] },
292        }),
293        path: Path {
294            leading_colon: Some(syn::token::PathSep {
295                spans: [span, span],
296            }),
297            segments: [
298                PathSegment {
299                    ident: Ident::new("xso", span),
300                    arguments: PathArguments::None,
301                },
302                PathSegment {
303                    ident: Ident::new("AsXmlText", span),
304                    arguments: PathArguments::None,
305                },
306                PathSegment {
307                    ident: Ident::new("as_xml_text", span),
308                    arguments: PathArguments::None,
309                },
310            ]
311            .into_iter()
312            .collect(),
313        },
314    })
315}
316
317/// Construct a [`syn::Path`] referring to `::xso::TextCodec::<#for_ty>`,
318/// returning the span of `for_ty` alongside it.
319///
320/// The span used is `codec_span`, in order to ensure that error messages
321/// about a missing implementation point at the codec, not at the type.
322fn text_codec_of(for_ty: Type, codec_span: Span) -> Path {
323    let span = codec_span;
324    Path {
325        leading_colon: Some(syn::token::PathSep {
326            spans: [span, span],
327        }),
328        segments: [
329            PathSegment {
330                ident: Ident::new("xso", span),
331                arguments: PathArguments::None,
332            },
333            PathSegment {
334                ident: Ident::new("TextCodec", span),
335                arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
336                    colon2_token: Some(syn::token::PathSep {
337                        spans: [span, span],
338                    }),
339                    lt_token: syn::token::Lt { spans: [span] },
340                    args: [GenericArgument::Type(for_ty)].into_iter().collect(),
341                    gt_token: syn::token::Gt { spans: [span] },
342                }),
343            },
344        ]
345        .into_iter()
346        .collect(),
347    }
348}
349
350/// Construct a [`syn::Expr`] referring to
351/// `::xso::TextCodec::<#for_ty>::encode`.
352///
353/// The span used is `codec_span`, in order to ensure that error messages
354/// about a missing implementation point at the codec, not at the type.
355pub(crate) fn text_codec_encode_fn(for_ty: Type, codec_span: Span) -> Expr {
356    let mut path = text_codec_of(for_ty, codec_span);
357    path.segments.push(PathSegment {
358        ident: Ident::new("encode", codec_span),
359        arguments: PathArguments::None,
360    });
361    Expr::Path(ExprPath {
362        attrs: Vec::new(),
363        qself: None,
364        path,
365    })
366}
367
368/// Construct a [`syn::Expr`] referring to
369/// `::xso::TextCodec::<#for_ty>::decode`.
370///
371/// The span used is `codec_span`, in order to ensure that error messages
372/// about a missing implementation point at the codec, not at the type.
373pub(crate) fn text_codec_decode_fn(for_ty: Type, codec_span: Span) -> Expr {
374    let mut path = text_codec_of(for_ty, codec_span);
375    path.segments.push(PathSegment {
376        ident: Ident::new("decode", codec_span),
377        arguments: PathArguments::None,
378    });
379    Expr::Path(ExprPath {
380        attrs: Vec::new(),
381        qself: None,
382        path,
383    })
384}
385
386/// Construct a [`syn::Type`] for `&#lifetime #ty`.
387pub(crate) fn ref_ty(ty: Type, lifetime: Lifetime) -> Type {
388    let span = ty.span();
389    Type::Reference(TypeReference {
390        and_token: token::And { spans: [span] },
391        lifetime: Some(lifetime),
392        mutability: None,
393        elem: Box::new(ty),
394    })
395}
396
397/// Construct a [`syn::Type`] referring to
398/// `::core::marker::PhantomData<&#lifetime ()>`.
399pub(crate) fn phantom_lifetime_ty(lifetime: Lifetime) -> Type {
400    let span = lifetime.span();
401    let dummy = Type::Tuple(TypeTuple {
402        paren_token: token::Paren::default(),
403        elems: punctuated::Punctuated::default(),
404    });
405    Type::Path(TypePath {
406        qself: None,
407        path: Path {
408            leading_colon: Some(syn::token::PathSep {
409                spans: [span, span],
410            }),
411            segments: [
412                PathSegment {
413                    ident: Ident::new("core", span),
414                    arguments: PathArguments::None,
415                },
416                PathSegment {
417                    ident: Ident::new("marker", span),
418                    arguments: PathArguments::None,
419                },
420                PathSegment {
421                    ident: Ident::new("PhantomData", span),
422                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
423                        colon2_token: None,
424                        lt_token: token::Lt { spans: [span] },
425                        args: [GenericArgument::Type(ref_ty(dummy, lifetime))]
426                            .into_iter()
427                            .collect(),
428                        gt_token: token::Gt { spans: [span] },
429                    }),
430                },
431            ]
432            .into_iter()
433            .collect(),
434        },
435    })
436}
437
438/// Construct a [`syn::TypePath`] referring to
439/// `<#of_ty as ::xso::FromXml>`.
440fn from_xml_of(of_ty: Type) -> (Span, TypePath) {
441    let span = of_ty.span();
442    (
443        span,
444        TypePath {
445            qself: Some(QSelf {
446                lt_token: syn::token::Lt { spans: [span] },
447                ty: Box::new(of_ty),
448                position: 2,
449                as_token: Some(syn::token::As { span }),
450                gt_token: syn::token::Gt { spans: [span] },
451            }),
452            path: Path {
453                leading_colon: Some(syn::token::PathSep {
454                    spans: [span, span],
455                }),
456                segments: [
457                    PathSegment {
458                        ident: Ident::new("xso", span),
459                        arguments: PathArguments::None,
460                    },
461                    PathSegment {
462                        ident: Ident::new("FromXml", span),
463                        arguments: PathArguments::None,
464                    },
465                ]
466                .into_iter()
467                .collect(),
468            },
469        },
470    )
471}
472
473/// Construct a [`syn::Type`] referring to
474/// `<#of_ty as ::xso::FromXml>::Builder`.
475pub(crate) fn from_xml_builder_ty(of_ty: Type) -> Type {
476    let (span, mut ty) = from_xml_of(of_ty);
477    ty.path.segments.push(PathSegment {
478        ident: Ident::new("Builder", span),
479        arguments: PathArguments::None,
480    });
481    Type::Path(ty)
482}
483
484/// Construct a [`syn::Expr`] referring to
485/// `<#of_ty as ::xso::FromXml>::from_events`.
486pub(crate) fn from_events_fn(of_ty: Type) -> Expr {
487    let (span, mut ty) = from_xml_of(of_ty);
488    ty.path.segments.push(PathSegment {
489        ident: Ident::new("from_events", span),
490        arguments: PathArguments::None,
491    });
492    Expr::Path(ExprPath {
493        attrs: Vec::new(),
494        qself: ty.qself,
495        path: ty.path,
496    })
497}
498
499/// Construct a [`syn::Type`] which wraps the given `ty` in
500/// `::core::option::Option<_>`.
501pub(crate) fn option_ty(ty: Type) -> Type {
502    let span = ty.span();
503    Type::Path(TypePath {
504        qself: None,
505        path: Path {
506            leading_colon: Some(syn::token::PathSep {
507                spans: [span, span],
508            }),
509            segments: [
510                PathSegment {
511                    ident: Ident::new("core", span),
512                    arguments: PathArguments::None,
513                },
514                PathSegment {
515                    ident: Ident::new("option", span),
516                    arguments: PathArguments::None,
517                },
518                PathSegment {
519                    ident: Ident::new("Option", span),
520                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
521                        colon2_token: None,
522                        lt_token: syn::token::Lt { spans: [span] },
523                        args: [GenericArgument::Type(ty)].into_iter().collect(),
524                        gt_token: syn::token::Gt { spans: [span] },
525                    }),
526                },
527            ]
528            .into_iter()
529            .collect(),
530        },
531    })
532}
533
534/// Construct a [`syn::TypePath`] referring to
535/// `<#of_ty as ::xso::FromEventsBuilder>`.
536fn from_events_builder_of(of_ty: Type) -> (Span, TypePath) {
537    let span = of_ty.span();
538    (
539        span,
540        TypePath {
541            qself: Some(QSelf {
542                lt_token: syn::token::Lt { spans: [span] },
543                ty: Box::new(of_ty),
544                position: 2,
545                as_token: Some(syn::token::As { span }),
546                gt_token: syn::token::Gt { spans: [span] },
547            }),
548            path: Path {
549                leading_colon: Some(syn::token::PathSep {
550                    spans: [span, span],
551                }),
552                segments: [
553                    PathSegment {
554                        ident: Ident::new("xso", span),
555                        arguments: PathArguments::None,
556                    },
557                    PathSegment {
558                        ident: Ident::new("FromEventsBuilder", span),
559                        arguments: PathArguments::None,
560                    },
561                ]
562                .into_iter()
563                .collect(),
564            },
565        },
566    )
567}
568
569/// Construct a [`syn::Expr`] referring to
570/// `<#of_ty as ::xso::FromEventsBuilder>::feed`.
571pub(crate) fn feed_fn(of_ty: Type) -> Expr {
572    let (span, mut ty) = from_events_builder_of(of_ty);
573    ty.path.segments.push(PathSegment {
574        ident: Ident::new("feed", span),
575        arguments: PathArguments::None,
576    });
577    Expr::Path(ExprPath {
578        attrs: Vec::new(),
579        qself: ty.qself,
580        path: ty.path,
581    })
582}
583
584fn as_xml_of(of_ty: Type) -> (Span, TypePath) {
585    let span = of_ty.span();
586    (
587        span,
588        TypePath {
589            qself: Some(QSelf {
590                lt_token: syn::token::Lt { spans: [span] },
591                ty: Box::new(of_ty),
592                position: 2,
593                as_token: Some(syn::token::As { span }),
594                gt_token: syn::token::Gt { spans: [span] },
595            }),
596            path: Path {
597                leading_colon: Some(syn::token::PathSep {
598                    spans: [span, span],
599                }),
600                segments: [
601                    PathSegment {
602                        ident: Ident::new("xso", span),
603                        arguments: PathArguments::None,
604                    },
605                    PathSegment {
606                        ident: Ident::new("AsXml", span),
607                        arguments: PathArguments::None,
608                    },
609                ]
610                .into_iter()
611                .collect(),
612            },
613        },
614    )
615}
616
617/// Construct a [`syn::Expr`] referring to
618/// `<#of_ty as ::xso::AsXml>::as_xml_iter`.
619pub(crate) fn as_xml_iter_fn(of_ty: Type) -> Expr {
620    let (span, mut ty) = as_xml_of(of_ty);
621    ty.path.segments.push(PathSegment {
622        ident: Ident::new("as_xml_iter", span),
623        arguments: PathArguments::None,
624    });
625    Expr::Path(ExprPath {
626        attrs: Vec::new(),
627        qself: ty.qself,
628        path: ty.path,
629    })
630}
631
632/// Construct a [`syn::Type`] referring to
633/// `<#of_ty as ::xso::AsXml>::ItemIter`.
634pub(crate) fn item_iter_ty(of_ty: Type, lifetime: Lifetime) -> Type {
635    let (span, mut ty) = as_xml_of(of_ty);
636    ty.path.segments.push(PathSegment {
637        ident: Ident::new("ItemIter", span),
638        arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
639            colon2_token: None,
640            lt_token: token::Lt { spans: [span] },
641            args: [GenericArgument::Lifetime(lifetime)].into_iter().collect(),
642            gt_token: token::Gt { spans: [span] },
643        }),
644    });
645    Type::Path(ty)
646}
647
648/// Construct a [`syn::TypePath`] referring to `<#of_ty as IntoIterator>`.
649fn into_iterator_of(of_ty: Type) -> (Span, TypePath) {
650    let span = of_ty.span();
651    (
652        span,
653        TypePath {
654            qself: Some(QSelf {
655                lt_token: syn::token::Lt { spans: [span] },
656                ty: Box::new(of_ty),
657                position: 3,
658                as_token: Some(syn::token::As { span }),
659                gt_token: syn::token::Gt { spans: [span] },
660            }),
661            path: Path {
662                leading_colon: Some(syn::token::PathSep {
663                    spans: [span, span],
664                }),
665                segments: [
666                    PathSegment {
667                        ident: Ident::new("core", span),
668                        arguments: PathArguments::None,
669                    },
670                    PathSegment {
671                        ident: Ident::new("iter", span),
672                        arguments: PathArguments::None,
673                    },
674                    PathSegment {
675                        ident: Ident::new("IntoIterator", span),
676                        arguments: PathArguments::None,
677                    },
678                ]
679                .into_iter()
680                .collect(),
681            },
682        },
683    )
684}
685
686/// Construct a [`syn::Type`] referring to
687/// `<#of_ty as IntoIterator>::IntoIter`.
688pub(crate) fn into_iterator_iter_ty(of_ty: Type) -> Type {
689    let (span, mut ty) = into_iterator_of(of_ty);
690    ty.path.segments.push(PathSegment {
691        ident: Ident::new("IntoIter", span),
692        arguments: PathArguments::None,
693    });
694    Type::Path(ty)
695}
696
697/// Construct a [`syn::Type`] referring to
698/// `<#of_ty as IntoIterator>::Item`.
699pub(crate) fn into_iterator_item_ty(of_ty: Type) -> Type {
700    let (span, mut ty) = into_iterator_of(of_ty);
701    ty.path.segments.push(PathSegment {
702        ident: Ident::new("Item", span),
703        arguments: PathArguments::None,
704    });
705    Type::Path(ty)
706}
707
708/// Construct a [`syn::Expr`] referring to
709/// `<#of_ty as IntoIterator>::into_iter`.
710pub(crate) fn into_iterator_into_iter_fn(of_ty: Type) -> Expr {
711    let (span, mut ty) = into_iterator_of(of_ty);
712    ty.path.segments.push(PathSegment {
713        ident: Ident::new("into_iter", span),
714        arguments: PathArguments::None,
715    });
716    Expr::Path(ExprPath {
717        attrs: Vec::new(),
718        qself: ty.qself,
719        path: ty.path,
720    })
721}
722
723/// Construct a [`syn::Expr`] referring to
724/// `<#of_ty as ::core::iter::Extend>::extend`.
725pub(crate) fn extend_fn(of_ty: Type, item_ty: Type) -> Expr {
726    let span = of_ty.span();
727    Expr::Path(ExprPath {
728        attrs: Vec::new(),
729        qself: Some(QSelf {
730            lt_token: syn::token::Lt { spans: [span] },
731            ty: Box::new(of_ty),
732            position: 3,
733            as_token: Some(syn::token::As { span }),
734            gt_token: syn::token::Gt { spans: [span] },
735        }),
736        path: Path {
737            leading_colon: Some(syn::token::PathSep {
738                spans: [span, span],
739            }),
740            segments: [
741                PathSegment {
742                    ident: Ident::new("core", span),
743                    arguments: PathArguments::None,
744                },
745                PathSegment {
746                    ident: Ident::new("iter", span),
747                    arguments: PathArguments::None,
748                },
749                PathSegment {
750                    ident: Ident::new("Extend", span),
751                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
752                        colon2_token: Some(syn::token::PathSep {
753                            spans: [span, span],
754                        }),
755                        lt_token: syn::token::Lt { spans: [span] },
756                        args: [GenericArgument::Type(item_ty)].into_iter().collect(),
757                        gt_token: syn::token::Gt { spans: [span] },
758                    }),
759                },
760                PathSegment {
761                    ident: Ident::new("extend", span),
762                    arguments: PathArguments::None,
763                },
764            ]
765            .into_iter()
766            .collect(),
767        },
768    })
769}
770
771/// Construct a [`syn::TypePath`] which references the given type name.
772pub(crate) fn ty_from_ident(ident: Ident) -> TypePath {
773    TypePath {
774        qself: None,
775        path: ident.into(),
776    }
777}
778
779/// Construct a [`syn::Type`] referring to `xso::OptionAsXml<#inner_ty>`.
780pub(crate) fn option_as_xml_ty(inner_ty: Type) -> Type {
781    let span = inner_ty.span();
782    Type::Path(TypePath {
783        qself: None,
784        path: Path {
785            leading_colon: Some(syn::token::PathSep {
786                spans: [span, span],
787            }),
788            segments: [
789                PathSegment {
790                    ident: Ident::new("xso", span),
791                    arguments: PathArguments::None,
792                },
793                PathSegment {
794                    ident: Ident::new("asxml", span),
795                    arguments: PathArguments::None,
796                },
797                PathSegment {
798                    ident: Ident::new("OptionAsXml", span),
799                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
800                        colon2_token: None,
801                        lt_token: token::Lt { spans: [span] },
802                        args: [GenericArgument::Type(inner_ty)].into_iter().collect(),
803                        gt_token: token::Gt { spans: [span] },
804                    }),
805                },
806            ]
807            .into_iter()
808            .collect(),
809        },
810    })
811}
812
813/// Construct a [`syn::Type`] referring to `::xso::exports::minidom::Element`.
814#[cfg(feature = "minidom")]
815pub(crate) fn element_ty(span: Span) -> Type {
816    Type::Path(TypePath {
817        qself: None,
818        path: Path {
819            leading_colon: Some(syn::token::PathSep {
820                spans: [span, span],
821            }),
822            segments: [
823                PathSegment {
824                    ident: Ident::new("xso", span),
825                    arguments: PathArguments::None,
826                },
827                PathSegment {
828                    ident: Ident::new("exports", span),
829                    arguments: PathArguments::None,
830                },
831                PathSegment {
832                    ident: Ident::new("minidom", span),
833                    arguments: PathArguments::None,
834                },
835                PathSegment {
836                    ident: Ident::new("Element", span),
837                    arguments: PathArguments::None,
838                },
839            ]
840            .into_iter()
841            .collect(),
842        },
843    })
844}
845
846/// Construct a [`syn::Path`] referring to `::xso::UnknownAttributePolicy`.
847pub(crate) fn unknown_attribute_policy_path(span: Span) -> Path {
848    Path {
849        leading_colon: Some(syn::token::PathSep {
850            spans: [span, span],
851        }),
852        segments: [
853            PathSegment {
854                ident: Ident::new("xso", span),
855                arguments: PathArguments::None,
856            },
857            PathSegment {
858                ident: Ident::new("UnknownAttributePolicy", span),
859                arguments: PathArguments::None,
860            },
861        ]
862        .into_iter()
863        .collect(),
864    }
865}
866
867/// Construct a [`syn::Path`] referring to `::xso::UnknownChildPolicy`.
868pub(crate) fn unknown_child_policy_path(span: Span) -> Path {
869    Path {
870        leading_colon: Some(syn::token::PathSep {
871            spans: [span, span],
872        }),
873        segments: [
874            PathSegment {
875                ident: Ident::new("xso", span),
876                arguments: PathArguments::None,
877            },
878            PathSegment {
879                ident: Ident::new("UnknownChildPolicy", span),
880                arguments: PathArguments::None,
881            },
882        ]
883        .into_iter()
884        .collect(),
885    }
886}
887
888/// Construct a [`syn::Type`] referring to `::xso::fromxml::Discard`.
889pub(crate) fn discard_builder_ty(span: Span) -> Type {
890    Type::Path(TypePath {
891        qself: None,
892        path: Path {
893            leading_colon: Some(syn::token::PathSep {
894                spans: [span, span],
895            }),
896            segments: [
897                PathSegment {
898                    ident: Ident::new("xso", span),
899                    arguments: PathArguments::None,
900                },
901                PathSegment {
902                    ident: Ident::new("fromxml", span),
903                    arguments: PathArguments::None,
904                },
905                PathSegment {
906                    ident: Ident::new("Discard", span),
907                    arguments: PathArguments::None,
908                },
909            ]
910            .into_iter()
911            .collect(),
912        },
913    })
914}
915
916/// Construct a [`syn::Type`] referring to the built-in `bool` type.
917///
918/// Note that we go through `xso::exports::CoreBool` for that, because there seems
919/// to be no way to access built-in types once they have been shadowed in a
920/// scope.
921pub(crate) fn bool_ty(span: Span) -> Type {
922    Type::Path(TypePath {
923        qself: None,
924        path: Path {
925            leading_colon: Some(syn::token::PathSep {
926                spans: [span, span],
927            }),
928            segments: [
929                PathSegment {
930                    ident: Ident::new("xso", span),
931                    arguments: PathArguments::None,
932                },
933                PathSegment {
934                    ident: Ident::new("exports", span),
935                    arguments: PathArguments::None,
936                },
937                PathSegment {
938                    ident: Ident::new("CoreBool", span),
939                    arguments: PathArguments::None,
940                },
941            ]
942            .into_iter()
943            .collect(),
944        },
945    })
946}
947
948/// Construct a [`syn::Type`] referring to the built-in `u8` type.
949///
950/// Note that we go through `xso::exports::CoreU8` for that, because there seems
951/// to be no way to access built-in types once they have been shadowed in a
952/// scope.
953pub(crate) fn u8_ty(span: Span) -> Type {
954    Type::Path(TypePath {
955        qself: None,
956        path: Path {
957            leading_colon: Some(syn::token::PathSep {
958                spans: [span, span],
959            }),
960            segments: [
961                PathSegment {
962                    ident: Ident::new("xso", span),
963                    arguments: PathArguments::None,
964                },
965                PathSegment {
966                    ident: Ident::new("exports", span),
967                    arguments: PathArguments::None,
968                },
969                PathSegment {
970                    ident: Ident::new("CoreU8", span),
971                    arguments: PathArguments::None,
972                },
973            ]
974            .into_iter()
975            .collect(),
976        },
977    })
978}
979
980/// Construct a [`syn::Type`] referring to `::xso::fromxml::EmptyBuilder`.
981pub(crate) fn empty_builder_ty(span: Span) -> Type {
982    Type::Path(TypePath {
983        qself: None,
984        path: Path {
985            leading_colon: Some(syn::token::PathSep {
986                spans: [span, span],
987            }),
988            segments: [
989                PathSegment {
990                    ident: Ident::new("xso", span),
991                    arguments: PathArguments::None,
992                },
993                PathSegment {
994                    ident: Ident::new("fromxml", span),
995                    arguments: PathArguments::None,
996                },
997                PathSegment {
998                    ident: Ident::new("EmptyBuilder", span),
999                    arguments: PathArguments::None,
1000                },
1001            ]
1002            .into_iter()
1003            .collect(),
1004        },
1005    })
1006}
xso_proc/types.rs

xso_proc/
types.rs
