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("std", span),
88 arguments: PathArguments::None,
89 },
90 PathSegment {
91 ident: Ident::new("borrow", span),
92 arguments: PathArguments::None,
93 },
94 PathSegment {
95 ident: Ident::new("Cow", span),
96 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
97 colon2_token: None,
98 lt_token: token::Lt { spans: [span] },
99 args: [
100 GenericArgument::Lifetime(lifetime),
101 GenericArgument::Type(ty),
102 ]
103 .into_iter()
104 .collect(),
105 gt_token: token::Gt { spans: [span] },
106 }),
107 },
108 ]
109 .into_iter()
110 .collect(),
111 },
112 })
113}
114
115/// Construct a [`syn::Type`] referring to
116/// `Cow<#lifetime, ::rxml::NcNameStr>`.
117pub(crate) fn ncnamestr_cow_ty(ty_span: Span, lifetime: Lifetime) -> Type {
118 cow_ty(ncnamestr_ty(ty_span), lifetime)
119}
120
121/// Construct a [`syn::Expr`] referring to
122/// `<#ty as ::xso::FromXmlText>::from_xml_text`.
123pub(crate) fn from_xml_text_fn(ty: Type) -> Expr {
124 let span = ty.span();
125 Expr::Path(ExprPath {
126 attrs: Vec::new(),
127 qself: Some(QSelf {
128 lt_token: syn::token::Lt { spans: [span] },
129 ty: Box::new(ty),
130 position: 2,
131 as_token: Some(syn::token::As { span }),
132 gt_token: syn::token::Gt { spans: [span] },
133 }),
134 path: Path {
135 leading_colon: Some(syn::token::PathSep {
136 spans: [span, span],
137 }),
138 segments: [
139 PathSegment {
140 ident: Ident::new("xso", span),
141 arguments: PathArguments::None,
142 },
143 PathSegment {
144 ident: Ident::new("FromXmlText", span),
145 arguments: PathArguments::None,
146 },
147 PathSegment {
148 ident: Ident::new("from_xml_text", span),
149 arguments: PathArguments::None,
150 },
151 ]
152 .into_iter()
153 .collect(),
154 },
155 })
156}
157
158/// Construct a [`syn::Expr`] referring to
159/// `<#ty as ::xso::AsOptionalXmlText>::as_optional_xml_text`.
160pub(crate) fn as_optional_xml_text_fn(ty: Type) -> Expr {
161 let span = ty.span();
162 Expr::Path(ExprPath {
163 attrs: Vec::new(),
164 qself: Some(QSelf {
165 lt_token: syn::token::Lt { spans: [span] },
166 ty: Box::new(ty),
167 position: 2,
168 as_token: Some(syn::token::As { span }),
169 gt_token: syn::token::Gt { spans: [span] },
170 }),
171 path: Path {
172 leading_colon: Some(syn::token::PathSep {
173 spans: [span, span],
174 }),
175 segments: [
176 PathSegment {
177 ident: Ident::new("xso", span),
178 arguments: PathArguments::None,
179 },
180 PathSegment {
181 ident: Ident::new("AsOptionalXmlText", span),
182 arguments: PathArguments::None,
183 },
184 PathSegment {
185 ident: Ident::new("as_optional_xml_text", span),
186 arguments: PathArguments::None,
187 },
188 ]
189 .into_iter()
190 .collect(),
191 },
192 })
193}
194
195/// Construct a [`syn::Expr`] referring to
196/// `<#of_ty as ::core::default::Default>::default`.
197pub(crate) fn default_fn(of_ty: Type) -> Expr {
198 let span = of_ty.span();
199 Expr::Path(ExprPath {
200 attrs: Vec::new(),
201 qself: Some(QSelf {
202 lt_token: syn::token::Lt { spans: [span] },
203 ty: Box::new(of_ty),
204 position: 3,
205 as_token: Some(syn::token::As { span }),
206 gt_token: syn::token::Gt { spans: [span] },
207 }),
208 path: Path {
209 leading_colon: Some(syn::token::PathSep {
210 spans: [span, span],
211 }),
212 segments: [
213 PathSegment {
214 ident: Ident::new("core", span),
215 arguments: PathArguments::None,
216 },
217 PathSegment {
218 ident: Ident::new("default", span),
219 arguments: PathArguments::None,
220 },
221 PathSegment {
222 ident: Ident::new("Default", span),
223 arguments: PathArguments::None,
224 },
225 PathSegment {
226 ident: Ident::new("default", span),
227 arguments: PathArguments::None,
228 },
229 ]
230 .into_iter()
231 .collect(),
232 },
233 })
234}
235
236/// Construct a [`syn::Type`] referring to `::std::string::String`.
237pub(crate) fn string_ty(span: Span) -> Type {
238 Type::Path(TypePath {
239 qself: None,
240 path: Path {
241 leading_colon: Some(syn::token::PathSep {
242 spans: [span, span],
243 }),
244 segments: [
245 PathSegment {
246 ident: Ident::new("std", span),
247 arguments: PathArguments::None,
248 },
249 PathSegment {
250 ident: Ident::new("string", span),
251 arguments: PathArguments::None,
252 },
253 PathSegment {
254 ident: Ident::new("String", span),
255 arguments: PathArguments::None,
256 },
257 ]
258 .into_iter()
259 .collect(),
260 },
261 })
262}
263
264/// Construct a [`syn::Expr`] referring to
265/// `<#ty as ::xso::AsXmlText>::as_xml_text`.
266pub(crate) fn as_xml_text_fn(ty: Type) -> Expr {
267 let span = ty.span();
268 Expr::Path(ExprPath {
269 attrs: Vec::new(),
270 qself: Some(QSelf {
271 lt_token: syn::token::Lt { spans: [span] },
272 ty: Box::new(ty),
273 position: 2,
274 as_token: Some(syn::token::As { span }),
275 gt_token: syn::token::Gt { spans: [span] },
276 }),
277 path: Path {
278 leading_colon: Some(syn::token::PathSep {
279 spans: [span, span],
280 }),
281 segments: [
282 PathSegment {
283 ident: Ident::new("xso", span),
284 arguments: PathArguments::None,
285 },
286 PathSegment {
287 ident: Ident::new("AsXmlText", span),
288 arguments: PathArguments::None,
289 },
290 PathSegment {
291 ident: Ident::new("as_xml_text", span),
292 arguments: PathArguments::None,
293 },
294 ]
295 .into_iter()
296 .collect(),
297 },
298 })
299}
300
301/// Construct a [`syn::Path`] referring to `::xso::TextCodec::<#for_ty>`,
302/// returing the span of `for_ty` alongside it.
303fn text_codec_of(for_ty: Type) -> (Span, Path) {
304 let span = for_ty.span();
305 (
306 span,
307 Path {
308 leading_colon: Some(syn::token::PathSep {
309 spans: [span, span],
310 }),
311 segments: [
312 PathSegment {
313 ident: Ident::new("xso", span),
314 arguments: PathArguments::None,
315 },
316 PathSegment {
317 ident: Ident::new("TextCodec", span),
318 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
319 colon2_token: Some(syn::token::PathSep {
320 spans: [span, span],
321 }),
322 lt_token: syn::token::Lt { spans: [span] },
323 args: [GenericArgument::Type(for_ty)].into_iter().collect(),
324 gt_token: syn::token::Gt { spans: [span] },
325 }),
326 },
327 ]
328 .into_iter()
329 .collect(),
330 },
331 )
332}
333
334/// Construct a [`syn::Expr`] referring to
335/// `::xso::TextCodec::<#for_ty>::encode`.
336pub(crate) fn text_codec_encode_fn(for_ty: Type) -> Expr {
337 let (span, mut path) = text_codec_of(for_ty);
338 path.segments.push(PathSegment {
339 ident: Ident::new("encode", span),
340 arguments: PathArguments::None,
341 });
342 Expr::Path(ExprPath {
343 attrs: Vec::new(),
344 qself: None,
345 path: path,
346 })
347}
348
349/// Construct a [`syn::Expr`] referring to
350/// `::xso::TextCodec::<#for_ty>::decode`.
351pub(crate) fn text_codec_decode_fn(for_ty: Type) -> Expr {
352 let (span, mut path) = text_codec_of(for_ty);
353 path.segments.push(PathSegment {
354 ident: Ident::new("decode", span),
355 arguments: PathArguments::None,
356 });
357 Expr::Path(ExprPath {
358 attrs: Vec::new(),
359 qself: None,
360 path: path,
361 })
362}
363
364/// Construct a [`syn::Type`] for `&#lifetime #ty`.
365pub(crate) fn ref_ty(ty: Type, lifetime: Lifetime) -> Type {
366 let span = ty.span();
367 Type::Reference(TypeReference {
368 and_token: token::And { spans: [span] },
369 lifetime: Some(lifetime),
370 mutability: None,
371 elem: Box::new(ty),
372 })
373}
374
375/// Construct a [`syn::Type`] referring to
376/// `::core::marker::PhantomData<&#lifetime ()>`.
377pub(crate) fn phantom_lifetime_ty(lifetime: Lifetime) -> Type {
378 let span = lifetime.span();
379 let dummy = Type::Tuple(TypeTuple {
380 paren_token: token::Paren::default(),
381 elems: punctuated::Punctuated::default(),
382 });
383 Type::Path(TypePath {
384 qself: None,
385 path: Path {
386 leading_colon: Some(syn::token::PathSep {
387 spans: [span, span],
388 }),
389 segments: [
390 PathSegment {
391 ident: Ident::new("core", span),
392 arguments: PathArguments::None,
393 },
394 PathSegment {
395 ident: Ident::new("marker", span),
396 arguments: PathArguments::None,
397 },
398 PathSegment {
399 ident: Ident::new("PhantomData", span),
400 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
401 colon2_token: None,
402 lt_token: token::Lt { spans: [span] },
403 args: [GenericArgument::Type(ref_ty(dummy, lifetime))]
404 .into_iter()
405 .collect(),
406 gt_token: token::Gt { spans: [span] },
407 }),
408 },
409 ]
410 .into_iter()
411 .collect(),
412 },
413 })
414}
415
416/// Construct a [`syn::TypePath`] referring to
417/// `<#of_ty as ::xso::FromXml>`.
418fn from_xml_of(of_ty: Type) -> (Span, TypePath) {
419 let span = of_ty.span();
420 (
421 span,
422 TypePath {
423 qself: Some(QSelf {
424 lt_token: syn::token::Lt { spans: [span] },
425 ty: Box::new(of_ty),
426 position: 2,
427 as_token: Some(syn::token::As { span }),
428 gt_token: syn::token::Gt { spans: [span] },
429 }),
430 path: Path {
431 leading_colon: Some(syn::token::PathSep {
432 spans: [span, span],
433 }),
434 segments: [
435 PathSegment {
436 ident: Ident::new("xso", span),
437 arguments: PathArguments::None,
438 },
439 PathSegment {
440 ident: Ident::new("FromXml", span),
441 arguments: PathArguments::None,
442 },
443 ]
444 .into_iter()
445 .collect(),
446 },
447 },
448 )
449}
450
451/// Construct a [`syn::Type`] referring to
452/// `<#of_ty as ::xso::FromXml>::Builder`.
453pub(crate) fn from_xml_builder_ty(of_ty: Type) -> Type {
454 let (span, mut ty) = from_xml_of(of_ty);
455 ty.path.segments.push(PathSegment {
456 ident: Ident::new("Builder", span),
457 arguments: PathArguments::None,
458 });
459 Type::Path(ty)
460}
461
462/// Construct a [`syn::Expr`] referring to
463/// `<#of_ty as ::xso::FromXml>::from_events`.
464pub(crate) fn from_events_fn(of_ty: Type) -> Expr {
465 let (span, mut ty) = from_xml_of(of_ty);
466 ty.path.segments.push(PathSegment {
467 ident: Ident::new("from_events", span),
468 arguments: PathArguments::None,
469 });
470 Expr::Path(ExprPath {
471 attrs: Vec::new(),
472 qself: ty.qself,
473 path: ty.path,
474 })
475}
476
477/// Construct a [`syn::Type`] which wraps the given `ty` in
478/// `::core::option::Option<_>`.
479pub(crate) fn option_ty(ty: Type) -> Type {
480 let span = ty.span();
481 Type::Path(TypePath {
482 qself: None,
483 path: Path {
484 leading_colon: Some(syn::token::PathSep {
485 spans: [span, span],
486 }),
487 segments: [
488 PathSegment {
489 ident: Ident::new("core", span),
490 arguments: PathArguments::None,
491 },
492 PathSegment {
493 ident: Ident::new("option", span),
494 arguments: PathArguments::None,
495 },
496 PathSegment {
497 ident: Ident::new("Option", span),
498 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
499 colon2_token: None,
500 lt_token: syn::token::Lt { spans: [span] },
501 args: [GenericArgument::Type(ty)].into_iter().collect(),
502 gt_token: syn::token::Gt { spans: [span] },
503 }),
504 },
505 ]
506 .into_iter()
507 .collect(),
508 },
509 })
510}
511
512/// Construct a [`syn::TypePath`] referring to
513/// `<#of_ty as ::xso::FromEventsBuilder>`.
514fn from_events_builder_of(of_ty: Type) -> (Span, TypePath) {
515 let span = of_ty.span();
516 (
517 span,
518 TypePath {
519 qself: Some(QSelf {
520 lt_token: syn::token::Lt { spans: [span] },
521 ty: Box::new(of_ty),
522 position: 2,
523 as_token: Some(syn::token::As { span }),
524 gt_token: syn::token::Gt { spans: [span] },
525 }),
526 path: Path {
527 leading_colon: Some(syn::token::PathSep {
528 spans: [span, span],
529 }),
530 segments: [
531 PathSegment {
532 ident: Ident::new("xso", span),
533 arguments: PathArguments::None,
534 },
535 PathSegment {
536 ident: Ident::new("FromEventsBuilder", span),
537 arguments: PathArguments::None,
538 },
539 ]
540 .into_iter()
541 .collect(),
542 },
543 },
544 )
545}
546
547/// Construct a [`syn::Expr`] referring to
548/// `<#of_ty as ::xso::FromEventsBuilder>::feed`.
549pub(crate) fn feed_fn(of_ty: Type) -> Expr {
550 let (span, mut ty) = from_events_builder_of(of_ty);
551 ty.path.segments.push(PathSegment {
552 ident: Ident::new("feed", span),
553 arguments: PathArguments::None,
554 });
555 Expr::Path(ExprPath {
556 attrs: Vec::new(),
557 qself: ty.qself,
558 path: ty.path,
559 })
560}
561
562fn as_xml_of(of_ty: Type) -> (Span, TypePath) {
563 let span = of_ty.span();
564 (
565 span,
566 TypePath {
567 qself: Some(QSelf {
568 lt_token: syn::token::Lt { spans: [span] },
569 ty: Box::new(of_ty),
570 position: 2,
571 as_token: Some(syn::token::As { span }),
572 gt_token: syn::token::Gt { spans: [span] },
573 }),
574 path: Path {
575 leading_colon: Some(syn::token::PathSep {
576 spans: [span, span],
577 }),
578 segments: [
579 PathSegment {
580 ident: Ident::new("xso", span),
581 arguments: PathArguments::None,
582 },
583 PathSegment {
584 ident: Ident::new("AsXml", span),
585 arguments: PathArguments::None,
586 },
587 ]
588 .into_iter()
589 .collect(),
590 },
591 },
592 )
593}
594
595/// Construct a [`syn::Expr`] referring to
596/// `<#of_ty as ::xso::AsXml>::as_xml_iter`.
597pub(crate) fn as_xml_iter_fn(of_ty: Type) -> Expr {
598 let (span, mut ty) = as_xml_of(of_ty);
599 ty.path.segments.push(PathSegment {
600 ident: Ident::new("as_xml_iter", span),
601 arguments: PathArguments::None,
602 });
603 Expr::Path(ExprPath {
604 attrs: Vec::new(),
605 qself: ty.qself,
606 path: ty.path,
607 })
608}
609
610/// Construct a [`syn::Type`] referring to
611/// `<#of_ty as ::xso::AsXml>::ItemIter`.
612pub(crate) fn item_iter_ty(of_ty: Type, lifetime: Lifetime) -> Type {
613 let (span, mut ty) = as_xml_of(of_ty);
614 ty.path.segments.push(PathSegment {
615 ident: Ident::new("ItemIter", span),
616 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
617 colon2_token: None,
618 lt_token: token::Lt { spans: [span] },
619 args: [GenericArgument::Lifetime(lifetime)].into_iter().collect(),
620 gt_token: token::Gt { spans: [span] },
621 }),
622 });
623 Type::Path(ty)
624}
625
626/// Construct a [`syn::TypePath`] referring to `<#of_ty as IntoIterator>`.
627fn into_iterator_of(of_ty: Type) -> (Span, TypePath) {
628 let span = of_ty.span();
629 (
630 span,
631 TypePath {
632 qself: Some(QSelf {
633 lt_token: syn::token::Lt { spans: [span] },
634 ty: Box::new(of_ty),
635 position: 3,
636 as_token: Some(syn::token::As { span }),
637 gt_token: syn::token::Gt { spans: [span] },
638 }),
639 path: Path {
640 leading_colon: Some(syn::token::PathSep {
641 spans: [span, span],
642 }),
643 segments: [
644 PathSegment {
645 ident: Ident::new("core", span),
646 arguments: PathArguments::None,
647 },
648 PathSegment {
649 ident: Ident::new("iter", span),
650 arguments: PathArguments::None,
651 },
652 PathSegment {
653 ident: Ident::new("IntoIterator", span),
654 arguments: PathArguments::None,
655 },
656 ]
657 .into_iter()
658 .collect(),
659 },
660 },
661 )
662}
663
664/// Construct a [`syn::Type`] referring to
665/// `<#of_ty as IntoIterator>::IntoIter`.
666pub(crate) fn into_iterator_iter_ty(of_ty: Type) -> Type {
667 let (span, mut ty) = into_iterator_of(of_ty);
668 ty.path.segments.push(PathSegment {
669 ident: Ident::new("IntoIter", span),
670 arguments: PathArguments::None,
671 });
672 Type::Path(ty)
673}
674
675/// Construct a [`syn::Type`] referring to
676/// `<#of_ty as IntoIterator>::Item`.
677pub(crate) fn into_iterator_item_ty(of_ty: Type) -> Type {
678 let (span, mut ty) = into_iterator_of(of_ty);
679 ty.path.segments.push(PathSegment {
680 ident: Ident::new("Item", span),
681 arguments: PathArguments::None,
682 });
683 Type::Path(ty)
684}
685
686/// Construct a [`syn::Expr`] referring to
687/// `<#of_ty as IntoIterator>::into_iter`.
688pub(crate) fn into_iterator_into_iter_fn(of_ty: Type) -> Expr {
689 let (span, mut ty) = into_iterator_of(of_ty);
690 ty.path.segments.push(PathSegment {
691 ident: Ident::new("into_iter", span),
692 arguments: PathArguments::None,
693 });
694 Expr::Path(ExprPath {
695 attrs: Vec::new(),
696 qself: ty.qself,
697 path: ty.path,
698 })
699}
700
701/// Construct a [`syn::Expr`] referring to
702/// `<#of_ty as ::core::iter::Extend>::extend`.
703pub(crate) fn extend_fn(of_ty: Type, item_ty: Type) -> Expr {
704 let span = of_ty.span();
705 Expr::Path(ExprPath {
706 attrs: Vec::new(),
707 qself: Some(QSelf {
708 lt_token: syn::token::Lt { spans: [span] },
709 ty: Box::new(of_ty),
710 position: 3,
711 as_token: Some(syn::token::As { span }),
712 gt_token: syn::token::Gt { spans: [span] },
713 }),
714 path: Path {
715 leading_colon: Some(syn::token::PathSep {
716 spans: [span, span],
717 }),
718 segments: [
719 PathSegment {
720 ident: Ident::new("core", span),
721 arguments: PathArguments::None,
722 },
723 PathSegment {
724 ident: Ident::new("iter", span),
725 arguments: PathArguments::None,
726 },
727 PathSegment {
728 ident: Ident::new("Extend", span),
729 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
730 colon2_token: Some(syn::token::PathSep {
731 spans: [span, span],
732 }),
733 lt_token: syn::token::Lt { spans: [span] },
734 args: [GenericArgument::Type(item_ty)].into_iter().collect(),
735 gt_token: syn::token::Gt { spans: [span] },
736 }),
737 },
738 PathSegment {
739 ident: Ident::new("extend", span),
740 arguments: PathArguments::None,
741 },
742 ]
743 .into_iter()
744 .collect(),
745 },
746 })
747}
748
749/// Construct a [`syn::TypePath`] which references the given type name.
750pub(crate) fn ty_from_ident(ident: Ident) -> TypePath {
751 TypePath {
752 qself: None,
753 path: ident.into(),
754 }
755}
756
757/// Construct a [`syn::Type`] referring to `xso::OptionAsXml<#inner_ty>`.
758pub(crate) fn option_as_xml_ty(inner_ty: Type) -> Type {
759 let span = inner_ty.span();
760 Type::Path(TypePath {
761 qself: None,
762 path: Path {
763 leading_colon: Some(syn::token::PathSep {
764 spans: [span, span],
765 }),
766 segments: [
767 PathSegment {
768 ident: Ident::new("xso", span),
769 arguments: PathArguments::None,
770 },
771 PathSegment {
772 ident: Ident::new("asxml", span),
773 arguments: PathArguments::None,
774 },
775 PathSegment {
776 ident: Ident::new("OptionAsXml", span),
777 arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
778 colon2_token: None,
779 lt_token: token::Lt { spans: [span] },
780 args: [GenericArgument::Type(inner_ty)].into_iter().collect(),
781 gt_token: token::Gt { spans: [span] },
782 }),
783 },
784 ]
785 .into_iter()
786 .collect(),
787 },
788 })
789}
790
791/// Construct a [`syn::Type`] referring to `::xso::exports::minidom::Element`.
792#[cfg(feature = "minidom")]
793pub(crate) fn element_ty(span: Span) -> Type {
794 Type::Path(TypePath {
795 qself: None,
796 path: Path {
797 leading_colon: Some(syn::token::PathSep {
798 spans: [span, span],
799 }),
800 segments: [
801 PathSegment {
802 ident: Ident::new("xso", span),
803 arguments: PathArguments::None,
804 },
805 PathSegment {
806 ident: Ident::new("exports", span),
807 arguments: PathArguments::None,
808 },
809 PathSegment {
810 ident: Ident::new("minidom", span),
811 arguments: PathArguments::None,
812 },
813 PathSegment {
814 ident: Ident::new("Element", span),
815 arguments: PathArguments::None,
816 },
817 ]
818 .into_iter()
819 .collect(),
820 },
821 })
822}