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.
319fn text_codec_of(for_ty: Type) -> (Span, Path) {
320    let span = for_ty.span();
321    (
322        span,
323        Path {
324            leading_colon: Some(syn::token::PathSep {
325                spans: [span, span],
326            }),
327            segments: [
328                PathSegment {
329                    ident: Ident::new("xso", span),
330                    arguments: PathArguments::None,
331                },
332                PathSegment {
333                    ident: Ident::new("TextCodec", span),
334                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
335                        colon2_token: Some(syn::token::PathSep {
336                            spans: [span, span],
337                        }),
338                        lt_token: syn::token::Lt { spans: [span] },
339                        args: [GenericArgument::Type(for_ty)].into_iter().collect(),
340                        gt_token: syn::token::Gt { spans: [span] },
341                    }),
342                },
343            ]
344            .into_iter()
345            .collect(),
346        },
347    )
348}
349
350/// Construct a [`syn::Expr`] referring to
351/// `::xso::TextCodec::<#for_ty>::encode`.
352pub(crate) fn text_codec_encode_fn(for_ty: Type) -> Expr {
353    let (span, mut path) = text_codec_of(for_ty);
354    path.segments.push(PathSegment {
355        ident: Ident::new("encode", span),
356        arguments: PathArguments::None,
357    });
358    Expr::Path(ExprPath {
359        attrs: Vec::new(),
360        qself: None,
361        path: path,
362    })
363}
364
365/// Construct a [`syn::Expr`] referring to
366/// `::xso::TextCodec::<#for_ty>::decode`.
367pub(crate) fn text_codec_decode_fn(for_ty: Type) -> Expr {
368    let (span, mut path) = text_codec_of(for_ty);
369    path.segments.push(PathSegment {
370        ident: Ident::new("decode", span),
371        arguments: PathArguments::None,
372    });
373    Expr::Path(ExprPath {
374        attrs: Vec::new(),
375        qself: None,
376        path: path,
377    })
378}
379
380/// Construct a [`syn::Type`] for `&#lifetime #ty`.
381pub(crate) fn ref_ty(ty: Type, lifetime: Lifetime) -> Type {
382    let span = ty.span();
383    Type::Reference(TypeReference {
384        and_token: token::And { spans: [span] },
385        lifetime: Some(lifetime),
386        mutability: None,
387        elem: Box::new(ty),
388    })
389}
390
391/// Construct a [`syn::Type`] referring to
392/// `::core::marker::PhantomData<&#lifetime ()>`.
393pub(crate) fn phantom_lifetime_ty(lifetime: Lifetime) -> Type {
394    let span = lifetime.span();
395    let dummy = Type::Tuple(TypeTuple {
396        paren_token: token::Paren::default(),
397        elems: punctuated::Punctuated::default(),
398    });
399    Type::Path(TypePath {
400        qself: None,
401        path: Path {
402            leading_colon: Some(syn::token::PathSep {
403                spans: [span, span],
404            }),
405            segments: [
406                PathSegment {
407                    ident: Ident::new("core", span),
408                    arguments: PathArguments::None,
409                },
410                PathSegment {
411                    ident: Ident::new("marker", span),
412                    arguments: PathArguments::None,
413                },
414                PathSegment {
415                    ident: Ident::new("PhantomData", span),
416                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
417                        colon2_token: None,
418                        lt_token: token::Lt { spans: [span] },
419                        args: [GenericArgument::Type(ref_ty(dummy, lifetime))]
420                            .into_iter()
421                            .collect(),
422                        gt_token: token::Gt { spans: [span] },
423                    }),
424                },
425            ]
426            .into_iter()
427            .collect(),
428        },
429    })
430}
431
432/// Construct a [`syn::TypePath`] referring to
433/// `<#of_ty as ::xso::FromXml>`.
434fn from_xml_of(of_ty: Type) -> (Span, TypePath) {
435    let span = of_ty.span();
436    (
437        span,
438        TypePath {
439            qself: Some(QSelf {
440                lt_token: syn::token::Lt { spans: [span] },
441                ty: Box::new(of_ty),
442                position: 2,
443                as_token: Some(syn::token::As { span }),
444                gt_token: syn::token::Gt { spans: [span] },
445            }),
446            path: Path {
447                leading_colon: Some(syn::token::PathSep {
448                    spans: [span, span],
449                }),
450                segments: [
451                    PathSegment {
452                        ident: Ident::new("xso", span),
453                        arguments: PathArguments::None,
454                    },
455                    PathSegment {
456                        ident: Ident::new("FromXml", span),
457                        arguments: PathArguments::None,
458                    },
459                ]
460                .into_iter()
461                .collect(),
462            },
463        },
464    )
465}
466
467/// Construct a [`syn::Type`] referring to
468/// `<#of_ty as ::xso::FromXml>::Builder`.
469pub(crate) fn from_xml_builder_ty(of_ty: Type) -> Type {
470    let (span, mut ty) = from_xml_of(of_ty);
471    ty.path.segments.push(PathSegment {
472        ident: Ident::new("Builder", span),
473        arguments: PathArguments::None,
474    });
475    Type::Path(ty)
476}
477
478/// Construct a [`syn::Expr`] referring to
479/// `<#of_ty as ::xso::FromXml>::from_events`.
480pub(crate) fn from_events_fn(of_ty: Type) -> Expr {
481    let (span, mut ty) = from_xml_of(of_ty);
482    ty.path.segments.push(PathSegment {
483        ident: Ident::new("from_events", span),
484        arguments: PathArguments::None,
485    });
486    Expr::Path(ExprPath {
487        attrs: Vec::new(),
488        qself: ty.qself,
489        path: ty.path,
490    })
491}
492
493/// Construct a [`syn::Type`] which wraps the given `ty` in
494/// `::core::option::Option<_>`.
495pub(crate) fn option_ty(ty: Type) -> Type {
496    let span = ty.span();
497    Type::Path(TypePath {
498        qself: None,
499        path: Path {
500            leading_colon: Some(syn::token::PathSep {
501                spans: [span, span],
502            }),
503            segments: [
504                PathSegment {
505                    ident: Ident::new("core", span),
506                    arguments: PathArguments::None,
507                },
508                PathSegment {
509                    ident: Ident::new("option", span),
510                    arguments: PathArguments::None,
511                },
512                PathSegment {
513                    ident: Ident::new("Option", span),
514                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
515                        colon2_token: None,
516                        lt_token: syn::token::Lt { spans: [span] },
517                        args: [GenericArgument::Type(ty)].into_iter().collect(),
518                        gt_token: syn::token::Gt { spans: [span] },
519                    }),
520                },
521            ]
522            .into_iter()
523            .collect(),
524        },
525    })
526}
527
528/// Construct a [`syn::TypePath`] referring to
529/// `<#of_ty as ::xso::FromEventsBuilder>`.
530fn from_events_builder_of(of_ty: Type) -> (Span, TypePath) {
531    let span = of_ty.span();
532    (
533        span,
534        TypePath {
535            qself: Some(QSelf {
536                lt_token: syn::token::Lt { spans: [span] },
537                ty: Box::new(of_ty),
538                position: 2,
539                as_token: Some(syn::token::As { span }),
540                gt_token: syn::token::Gt { spans: [span] },
541            }),
542            path: Path {
543                leading_colon: Some(syn::token::PathSep {
544                    spans: [span, span],
545                }),
546                segments: [
547                    PathSegment {
548                        ident: Ident::new("xso", span),
549                        arguments: PathArguments::None,
550                    },
551                    PathSegment {
552                        ident: Ident::new("FromEventsBuilder", span),
553                        arguments: PathArguments::None,
554                    },
555                ]
556                .into_iter()
557                .collect(),
558            },
559        },
560    )
561}
562
563/// Construct a [`syn::Expr`] referring to
564/// `<#of_ty as ::xso::FromEventsBuilder>::feed`.
565pub(crate) fn feed_fn(of_ty: Type) -> Expr {
566    let (span, mut ty) = from_events_builder_of(of_ty);
567    ty.path.segments.push(PathSegment {
568        ident: Ident::new("feed", span),
569        arguments: PathArguments::None,
570    });
571    Expr::Path(ExprPath {
572        attrs: Vec::new(),
573        qself: ty.qself,
574        path: ty.path,
575    })
576}
577
578fn as_xml_of(of_ty: Type) -> (Span, TypePath) {
579    let span = of_ty.span();
580    (
581        span,
582        TypePath {
583            qself: Some(QSelf {
584                lt_token: syn::token::Lt { spans: [span] },
585                ty: Box::new(of_ty),
586                position: 2,
587                as_token: Some(syn::token::As { span }),
588                gt_token: syn::token::Gt { spans: [span] },
589            }),
590            path: Path {
591                leading_colon: Some(syn::token::PathSep {
592                    spans: [span, span],
593                }),
594                segments: [
595                    PathSegment {
596                        ident: Ident::new("xso", span),
597                        arguments: PathArguments::None,
598                    },
599                    PathSegment {
600                        ident: Ident::new("AsXml", span),
601                        arguments: PathArguments::None,
602                    },
603                ]
604                .into_iter()
605                .collect(),
606            },
607        },
608    )
609}
610
611/// Construct a [`syn::Expr`] referring to
612/// `<#of_ty as ::xso::AsXml>::as_xml_iter`.
613pub(crate) fn as_xml_iter_fn(of_ty: Type) -> Expr {
614    let (span, mut ty) = as_xml_of(of_ty);
615    ty.path.segments.push(PathSegment {
616        ident: Ident::new("as_xml_iter", span),
617        arguments: PathArguments::None,
618    });
619    Expr::Path(ExprPath {
620        attrs: Vec::new(),
621        qself: ty.qself,
622        path: ty.path,
623    })
624}
625
626/// Construct a [`syn::Type`] referring to
627/// `<#of_ty as ::xso::AsXml>::ItemIter`.
628pub(crate) fn item_iter_ty(of_ty: Type, lifetime: Lifetime) -> Type {
629    let (span, mut ty) = as_xml_of(of_ty);
630    ty.path.segments.push(PathSegment {
631        ident: Ident::new("ItemIter", span),
632        arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
633            colon2_token: None,
634            lt_token: token::Lt { spans: [span] },
635            args: [GenericArgument::Lifetime(lifetime)].into_iter().collect(),
636            gt_token: token::Gt { spans: [span] },
637        }),
638    });
639    Type::Path(ty)
640}
641
642/// Construct a [`syn::TypePath`] referring to `<#of_ty as IntoIterator>`.
643fn into_iterator_of(of_ty: Type) -> (Span, TypePath) {
644    let span = of_ty.span();
645    (
646        span,
647        TypePath {
648            qself: Some(QSelf {
649                lt_token: syn::token::Lt { spans: [span] },
650                ty: Box::new(of_ty),
651                position: 3,
652                as_token: Some(syn::token::As { span }),
653                gt_token: syn::token::Gt { spans: [span] },
654            }),
655            path: Path {
656                leading_colon: Some(syn::token::PathSep {
657                    spans: [span, span],
658                }),
659                segments: [
660                    PathSegment {
661                        ident: Ident::new("core", span),
662                        arguments: PathArguments::None,
663                    },
664                    PathSegment {
665                        ident: Ident::new("iter", span),
666                        arguments: PathArguments::None,
667                    },
668                    PathSegment {
669                        ident: Ident::new("IntoIterator", span),
670                        arguments: PathArguments::None,
671                    },
672                ]
673                .into_iter()
674                .collect(),
675            },
676        },
677    )
678}
679
680/// Construct a [`syn::Type`] referring to
681/// `<#of_ty as IntoIterator>::IntoIter`.
682pub(crate) fn into_iterator_iter_ty(of_ty: Type) -> Type {
683    let (span, mut ty) = into_iterator_of(of_ty);
684    ty.path.segments.push(PathSegment {
685        ident: Ident::new("IntoIter", span),
686        arguments: PathArguments::None,
687    });
688    Type::Path(ty)
689}
690
691/// Construct a [`syn::Type`] referring to
692/// `<#of_ty as IntoIterator>::Item`.
693pub(crate) fn into_iterator_item_ty(of_ty: Type) -> Type {
694    let (span, mut ty) = into_iterator_of(of_ty);
695    ty.path.segments.push(PathSegment {
696        ident: Ident::new("Item", span),
697        arguments: PathArguments::None,
698    });
699    Type::Path(ty)
700}
701
702/// Construct a [`syn::Expr`] referring to
703/// `<#of_ty as IntoIterator>::into_iter`.
704pub(crate) fn into_iterator_into_iter_fn(of_ty: Type) -> Expr {
705    let (span, mut ty) = into_iterator_of(of_ty);
706    ty.path.segments.push(PathSegment {
707        ident: Ident::new("into_iter", span),
708        arguments: PathArguments::None,
709    });
710    Expr::Path(ExprPath {
711        attrs: Vec::new(),
712        qself: ty.qself,
713        path: ty.path,
714    })
715}
716
717/// Construct a [`syn::Expr`] referring to
718/// `<#of_ty as ::core::iter::Extend>::extend`.
719pub(crate) fn extend_fn(of_ty: Type, item_ty: Type) -> Expr {
720    let span = of_ty.span();
721    Expr::Path(ExprPath {
722        attrs: Vec::new(),
723        qself: Some(QSelf {
724            lt_token: syn::token::Lt { spans: [span] },
725            ty: Box::new(of_ty),
726            position: 3,
727            as_token: Some(syn::token::As { span }),
728            gt_token: syn::token::Gt { spans: [span] },
729        }),
730        path: Path {
731            leading_colon: Some(syn::token::PathSep {
732                spans: [span, span],
733            }),
734            segments: [
735                PathSegment {
736                    ident: Ident::new("core", span),
737                    arguments: PathArguments::None,
738                },
739                PathSegment {
740                    ident: Ident::new("iter", span),
741                    arguments: PathArguments::None,
742                },
743                PathSegment {
744                    ident: Ident::new("Extend", span),
745                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
746                        colon2_token: Some(syn::token::PathSep {
747                            spans: [span, span],
748                        }),
749                        lt_token: syn::token::Lt { spans: [span] },
750                        args: [GenericArgument::Type(item_ty)].into_iter().collect(),
751                        gt_token: syn::token::Gt { spans: [span] },
752                    }),
753                },
754                PathSegment {
755                    ident: Ident::new("extend", span),
756                    arguments: PathArguments::None,
757                },
758            ]
759            .into_iter()
760            .collect(),
761        },
762    })
763}
764
765/// Construct a [`syn::TypePath`] which references the given type name.
766pub(crate) fn ty_from_ident(ident: Ident) -> TypePath {
767    TypePath {
768        qself: None,
769        path: ident.into(),
770    }
771}
772
773/// Construct a [`syn::Type`] referring to `xso::OptionAsXml<#inner_ty>`.
774pub(crate) fn option_as_xml_ty(inner_ty: Type) -> Type {
775    let span = inner_ty.span();
776    Type::Path(TypePath {
777        qself: None,
778        path: Path {
779            leading_colon: Some(syn::token::PathSep {
780                spans: [span, span],
781            }),
782            segments: [
783                PathSegment {
784                    ident: Ident::new("xso", span),
785                    arguments: PathArguments::None,
786                },
787                PathSegment {
788                    ident: Ident::new("asxml", span),
789                    arguments: PathArguments::None,
790                },
791                PathSegment {
792                    ident: Ident::new("OptionAsXml", span),
793                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
794                        colon2_token: None,
795                        lt_token: token::Lt { spans: [span] },
796                        args: [GenericArgument::Type(inner_ty)].into_iter().collect(),
797                        gt_token: token::Gt { spans: [span] },
798                    }),
799                },
800            ]
801            .into_iter()
802            .collect(),
803        },
804    })
805}
806
807/// Construct a [`syn::Type`] referring to `::xso::exports::minidom::Element`.
808#[cfg(feature = "minidom")]
809pub(crate) fn element_ty(span: Span) -> Type {
810    Type::Path(TypePath {
811        qself: None,
812        path: Path {
813            leading_colon: Some(syn::token::PathSep {
814                spans: [span, span],
815            }),
816            segments: [
817                PathSegment {
818                    ident: Ident::new("xso", span),
819                    arguments: PathArguments::None,
820                },
821                PathSegment {
822                    ident: Ident::new("exports", span),
823                    arguments: PathArguments::None,
824                },
825                PathSegment {
826                    ident: Ident::new("minidom", span),
827                    arguments: PathArguments::None,
828                },
829                PathSegment {
830                    ident: Ident::new("Element", span),
831                    arguments: PathArguments::None,
832                },
833            ]
834            .into_iter()
835            .collect(),
836        },
837    })
838}
839
840/// Construct a [`syn::Path`] referring to `::xso::UnknownAttributePolicy`.
841pub(crate) fn unknown_attribute_policy_path(span: Span) -> Path {
842    Path {
843        leading_colon: Some(syn::token::PathSep {
844            spans: [span, span],
845        }),
846        segments: [
847            PathSegment {
848                ident: Ident::new("xso", span),
849                arguments: PathArguments::None,
850            },
851            PathSegment {
852                ident: Ident::new("UnknownAttributePolicy", span),
853                arguments: PathArguments::None,
854            },
855        ]
856        .into_iter()
857        .collect(),
858    }
859}
860
861/// Construct a [`syn::Path`] referring to `::xso::UnknownChildPolicy`.
862pub(crate) fn unknown_child_policy_path(span: Span) -> Path {
863    Path {
864        leading_colon: Some(syn::token::PathSep {
865            spans: [span, span],
866        }),
867        segments: [
868            PathSegment {
869                ident: Ident::new("xso", span),
870                arguments: PathArguments::None,
871            },
872            PathSegment {
873                ident: Ident::new("UnknownChildPolicy", span),
874                arguments: PathArguments::None,
875            },
876        ]
877        .into_iter()
878        .collect(),
879    }
880}
881
882/// Construct a [`syn::Type`] referring to `::xso::fromxml::Discard`.
883pub(crate) fn discard_builder_ty(span: Span) -> Type {
884    Type::Path(TypePath {
885        qself: None,
886        path: Path {
887            leading_colon: Some(syn::token::PathSep {
888                spans: [span, span],
889            }),
890            segments: [
891                PathSegment {
892                    ident: Ident::new("xso", span),
893                    arguments: PathArguments::None,
894                },
895                PathSegment {
896                    ident: Ident::new("fromxml", span),
897                    arguments: PathArguments::None,
898                },
899                PathSegment {
900                    ident: Ident::new("Discard", span),
901                    arguments: PathArguments::None,
902                },
903            ]
904            .into_iter()
905            .collect(),
906        },
907    })
908}
909
910/// Construct a [`syn::Type`] referring to the built-in `bool` type.
911///
912/// Note that we go through `xso::exports::CoreBool` for that, because there seems
913/// to be no way to access built-in types once they have been shadowed in a
914/// scope.
915pub(crate) fn bool_ty(span: Span) -> Type {
916    Type::Path(TypePath {
917        qself: None,
918        path: Path {
919            leading_colon: Some(syn::token::PathSep {
920                spans: [span, span],
921            }),
922            segments: [
923                PathSegment {
924                    ident: Ident::new("xso", span),
925                    arguments: PathArguments::None,
926                },
927                PathSegment {
928                    ident: Ident::new("exports", span),
929                    arguments: PathArguments::None,
930                },
931                PathSegment {
932                    ident: Ident::new("CoreBool", span),
933                    arguments: PathArguments::None,
934                },
935            ]
936            .into_iter()
937            .collect(),
938        },
939    })
940}
941
942/// Construct a [`syn::Type`] referring to the built-in `u8` type.
943///
944/// Note that we go through `xso::exports::CoreU8` for that, because there seems
945/// to be no way to access built-in types once they have been shadowed in a
946/// scope.
947pub(crate) fn u8_ty(span: Span) -> Type {
948    Type::Path(TypePath {
949        qself: None,
950        path: Path {
951            leading_colon: Some(syn::token::PathSep {
952                spans: [span, span],
953            }),
954            segments: [
955                PathSegment {
956                    ident: Ident::new("xso", span),
957                    arguments: PathArguments::None,
958                },
959                PathSegment {
960                    ident: Ident::new("exports", span),
961                    arguments: PathArguments::None,
962                },
963                PathSegment {
964                    ident: Ident::new("CoreU8", span),
965                    arguments: PathArguments::None,
966                },
967            ]
968            .into_iter()
969            .collect(),
970        },
971    })
972}
973
974/// Construct a [`syn::Type`] referring to `::xso::fromxml::EmptyBuilder`.
975pub(crate) fn empty_builder_ty(span: Span) -> Type {
976    Type::Path(TypePath {
977        qself: None,
978        path: Path {
979            leading_colon: Some(syn::token::PathSep {
980                spans: [span, span],
981            }),
982            segments: [
983                PathSegment {
984                    ident: Ident::new("xso", span),
985                    arguments: PathArguments::None,
986                },
987                PathSegment {
988                    ident: Ident::new("fromxml", span),
989                    arguments: PathArguments::None,
990                },
991                PathSegment {
992                    ident: Ident::new("EmptyBuilder", span),
993                    arguments: PathArguments::None,
994                },
995            ]
996            .into_iter()
997            .collect(),
998        },
999    })
1000}
xso_proc/types.rs

xso_proc/
types.rs
