/*!
# Helper functions for working with [`syn::Type`]

This module provides helper functions which create or transform [`syn::Type`]
items.
*/
use proc_macro2::Span;

use syn::{spanned::Spanned, *};

/// Construct a [`syn::Type`] which wraps the given `ty` in
/// `::std::option::Option<_>`.
pub(crate) fn option_ty(ty: Type) -> Type {
    let span = ty.span();
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("std", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("option", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("Option", span),
                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                        colon2_token: None,
                        lt_token: syn::token::Lt { spans: [span] },
                        args: [GenericArgument::Type(ty)].into_iter().collect(),
                        gt_token: syn::token::Gt { spans: [span] },
                    }),
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] which wraps the given `ty` in
/// `::std::marker::PhantomData<_>`.
pub(crate) fn phantom_ty(ty: Type) -> Type {
    let span = ty.span();
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("std", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("marker", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("PhantomData", span),
                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                        colon2_token: None,
                        lt_token: syn::token::Lt { spans: [span] },
                        args: [GenericArgument::Type(ty)].into_iter().collect(),
                        gt_token: syn::token::Gt { spans: [span] },
                    }),
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `::std::string::String`.
pub(crate) fn string_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("std", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("string", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("String", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `::xso::exports::rxml::QName`.
pub(crate) fn qname_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("exports", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("rxml", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("QName", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `::xso::exports::rxml::AttrMap`.
pub(crate) fn attr_map_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("exports", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("rxml", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("AttrMap", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `::xso::DiscardEvents`.
pub(crate) fn discard_events_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("DiscardEvents", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `u8`.
pub(crate) fn primitive_ty(name: &str, span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: None,
            segments: [PathSegment {
                ident: Ident::new(name, span),
                arguments: PathArguments::None,
            }]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Type`] referring to `::xso::exports::minidom::Element`.
pub(crate) fn element_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("exports", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("minidom", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("Element", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::TypePath`] referring to
/// `<#of_ty as ::xso::FromXml>`.
fn from_xml_of(of_ty: Type) -> (Span, TypePath) {
    let span = of_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(of_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("FromXml", span),
                        arguments: PathArguments::None,
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Type`] referring to
/// `<#of_ty as ::xso::FromXml>::Builder`.
pub(crate) fn from_xml_builder_ty(of_ty: Type) -> Type {
    let (span, mut ty) = from_xml_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("Builder", span),
        arguments: PathArguments::None,
    });
    Type::Path(ty)
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::xso::FromXml>::from_events`.
pub(crate) fn from_events_fn(of_ty: Type) -> Expr {
    let (span, mut ty) = from_xml_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("from_events", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::TypePath`] referring to
/// `<#of_ty as ::xso::FromEventsBuilder>`.
fn from_events_builder_of(of_ty: Type) -> (Span, TypePath) {
    let span = of_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(of_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("FromEventsBuilder", span),
                        arguments: PathArguments::None,
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::xso::FromEventsBuilder>::feed`.
pub(crate) fn feed_fn(of_ty: Type) -> Expr {
    let (span, mut ty) = from_events_builder_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("feed", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

fn into_event_iter_of(of_ty: Type) -> (Span, TypePath) {
    let span = of_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(of_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("IntoXml", span),
                        arguments: PathArguments::None,
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::xso::IntoEventsIter>::into_event_iter`.
pub(crate) fn into_event_iter_fn(of_ty: Type) -> Expr {
    let (span, mut ty) = into_event_iter_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("into_event_iter", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Type`] referring to
/// `<#of_ty as ::xso::IntoEventsIter>::EventIter`.
pub(crate) fn event_iter_ty(of_ty: Type) -> Type {
    let (span, mut ty) = into_event_iter_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("EventIter", span),
        arguments: PathArguments::None,
    });
    Type::Path(ty)
}

/// Construct a [`syn::Type`] referring to
/// `::std::vec::IntoIter<#of_ty>`.
pub(crate) fn vec_into_iter_ty(of_ty: Type) -> Type {
    let span = of_ty.span();
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("std", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("vec", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("IntoIter", span),
                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                        colon2_token: None,
                        lt_token: syn::token::Lt { spans: [span] },
                        args: [GenericArgument::Type(of_ty)].into_iter().collect(),
                        gt_token: syn::token::Gt { spans: [span] },
                    }),
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::TypePath`] referring to `<#of_ty as IntoIterator>`.
fn into_iterator_of(of_ty: Type) -> (Span, TypePath) {
    let span = of_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(of_ty),
                position: 3,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("std", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("iter", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("IntoIterator", span),
                        arguments: PathArguments::None,
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Type`] referring to
/// `<#of_ty as IntoIterator>::IntoIter`.
pub(crate) fn into_iterator_iter_ty(of_ty: Type) -> Type {
    let (span, mut ty) = into_iterator_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("IntoIter", span),
        arguments: PathArguments::None,
    });
    Type::Path(ty)
}

/// Construct a [`syn::Type`] referring to
/// `<#of_ty as IntoIterator>::Item`.
pub(crate) fn into_iterator_item_ty(of_ty: Type) -> Type {
    let (span, mut ty) = into_iterator_of(of_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("Item", span),
        arguments: PathArguments::None,
    });
    Type::Path(ty)
}

fn element_codec_of(codec_ty: Type, for_ty: Type) -> (Span, TypePath) {
    let span = codec_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(codec_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("ElementCodec", span),
                        arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                            colon2_token: Some(syn::token::PathSep {
                                spans: [span, span],
                            }),
                            lt_token: syn::token::Lt { spans: [span] },
                            args: [GenericArgument::Type(for_ty)].into_iter().collect(),
                            gt_token: syn::token::Gt { spans: [span] },
                        }),
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Expr`] referring to
/// `<#codec_ty as ::xso::ElementCodec::<#for_ty>>::encode`.
pub(crate) fn element_codec_encode_fn(codec_ty: Type, for_ty: Type) -> Expr {
    let (span, mut ty) = element_codec_of(codec_ty, for_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("encode", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#codec_ty as ::xso::ElementCodec::<#for_ty>>::decode`.
pub(crate) fn element_codec_decode_fn(codec_ty: Type, for_ty: Type) -> Expr {
    let (span, mut ty) = element_codec_of(codec_ty, for_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("decode", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

fn text_codec_of(codec_ty: Type, for_ty: Type) -> (Span, TypePath) {
    let span = codec_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(codec_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("TextCodec", span),
                        arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                            colon2_token: Some(syn::token::PathSep {
                                spans: [span, span],
                            }),
                            lt_token: syn::token::Lt { spans: [span] },
                            args: [GenericArgument::Type(for_ty)].into_iter().collect(),
                            gt_token: syn::token::Gt { spans: [span] },
                        }),
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Expr`] referring to
/// `<#codec_ty as ::xso::TextCodec::<#for_ty>>::encode`.
pub(crate) fn text_codec_encode_fn(codec_ty: Type, for_ty: Type) -> Expr {
    let (span, mut ty) = text_codec_of(codec_ty, for_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("encode", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#codec_ty as ::xso::TextCodec::<#for_ty>>::decode`.
pub(crate) fn text_codec_decode_fn(codec_ty: Type, for_ty: Type) -> Expr {
    let (span, mut ty) = text_codec_of(codec_ty, for_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("decode", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#ty as ::xso::IntoXmlText>::into_xml_text`.
pub(crate) fn into_xml_text_fn(ty: Type) -> Expr {
    let span = ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(ty),
            position: 2,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("IntoXmlText", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("into_xml_text", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#ty as ::xso::IntoOptionalXmlText>::into_optional_xml_text`.
pub(crate) fn into_optional_xml_text_fn(ty: Type) -> Expr {
    let span = ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(ty),
            position: 2,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("IntoOptionalXmlText", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("into_optional_xml_text", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#ty as ::xso::FromXmlText>::from_xml_text`.
pub(crate) fn from_xml_text_fn(ty: Type) -> Expr {
    let span = ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(ty),
            position: 2,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("FromXmlText", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("from_xml_text", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#ty as ::xso::FromOptionalXmlText>::from_optional_xml_text`.
pub(crate) fn from_optional_xml_text_fn(ty: Type) -> Expr {
    let span = ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(ty),
            position: 2,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("FromOptionalXmlText", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("from_optional_xml_text", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::std::default::Default>::default`.
pub(crate) fn default_fn(of_ty: Type) -> Expr {
    let span = of_ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(of_ty),
            position: 3,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("std", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("default", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("Default", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("default", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::xso::TryExtend>::try_extend`.
pub(crate) fn try_extend_fn(of_ty: Type, item_ty: Type) -> Expr {
    let span = of_ty.span();
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: Some(QSelf {
            lt_token: syn::token::Lt { spans: [span] },
            ty: Box::new(of_ty),
            position: 2,
            as_token: Some(syn::token::As { span }),
            gt_token: syn::token::Gt { spans: [span] },
        }),
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("TryExtend", span),
                    arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
                        colon2_token: Some(syn::token::PathSep {
                            spans: [span, span],
                        }),
                        lt_token: syn::token::Lt { spans: [span] },
                        args: [GenericArgument::Type(item_ty)].into_iter().collect(),
                        gt_token: syn::token::Gt { spans: [span] },
                    }),
                },
                PathSegment {
                    ident: Ident::new("try_extend", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

fn dyn_namespace_of(codec_ty: Type) -> (Span, TypePath) {
    let span = codec_ty.span();
    (
        span,
        TypePath {
            qself: Some(QSelf {
                lt_token: syn::token::Lt { spans: [span] },
                ty: Box::new(codec_ty),
                position: 2,
                as_token: Some(syn::token::As { span }),
                gt_token: syn::token::Gt { spans: [span] },
            }),
            path: Path {
                leading_colon: Some(syn::token::PathSep {
                    spans: [span, span],
                }),
                segments: [
                    PathSegment {
                        ident: Ident::new("xso", span),
                        arguments: PathArguments::None,
                    },
                    PathSegment {
                        ident: Ident::new("DynNamespace", span),
                        arguments: PathArguments::None,
                    },
                ]
                .into_iter()
                .collect(),
            },
        },
    )
}

/// Construct a [`syn::Expr`] referring to
/// `<#of_ty as ::xso::DynNamespace>::set_namespace`.
pub(crate) fn dyn_namespace_set_fn(codec_ty: Type) -> Expr {
    let (span, mut ty) = dyn_namespace_of(codec_ty);
    ty.path.segments.push(PathSegment {
        ident: Ident::new("set_namespace", span),
        arguments: PathArguments::None,
    });
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Type`] referring to `xso::UnknownAttributePolicy`.
pub(crate) fn unknown_attribute_policy_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("UnknownAttributePolicy", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `xso::UnknownAttributePolicy::#ident`.
pub(crate) fn unknown_attribute_policy_variant(ident: Ident) -> Expr {
    let span = ident.span();
    let Type::Path(mut ty) = unknown_attribute_policy_ty(span) else {
        unreachable!();
    };
    ty.path.segments.push(ident.into());
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Type`] referring to `xso::UnknownChildPolicy`.
pub(crate) fn unknown_child_policy_ty(span: Span) -> Type {
    Type::Path(TypePath {
        qself: None,
        path: Path {
            leading_colon: Some(syn::token::PathSep {
                spans: [span, span],
            }),
            segments: [
                PathSegment {
                    ident: Ident::new("xso", span),
                    arguments: PathArguments::None,
                },
                PathSegment {
                    ident: Ident::new("UnknownChildPolicy", span),
                    arguments: PathArguments::None,
                },
            ]
            .into_iter()
            .collect(),
        },
    })
}

/// Construct a [`syn::Expr`] referring to
/// `xso::UnknownChildPolicy::#ident`.
pub(crate) fn unknown_child_policy_variant(ident: Ident) -> Expr {
    let span = ident.span();
    let Type::Path(mut ty) = unknown_child_policy_ty(span) else {
        unreachable!();
    };
    ty.path.segments.push(ident.into());
    Expr::Path(ExprPath {
        attrs: Vec::new(),
        qself: ty.qself,
        path: ty.path,
    })
}

/// Construct a [`syn::Expr`] containing
/// `<#ty as ::std::default::Default>::default()` (including the call!).
pub(crate) fn default_value(ty: Type) -> Expr {
    Expr::Call(ExprCall {
        attrs: Vec::new(),
        func: Box::new(default_fn(ty)),
        paren_token: syn::token::Paren::default(),
        args: syn::punctuated::Punctuated::default(),
    })
}

/// Construct a [`syn::TypePath`] which references the given type name.
pub(crate) fn ty_from_ident(ident: Ident) -> TypePath {
    TypePath {
        qself: None,
        path: ident.into(),
    }
}