async-codegen 0.12.1

/*
 * Copyright © 2025 Anand Beh
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use super::*;
use crate::common::{CombinedSeq, SeparatedSeqAccept, SingularSeq, Str};
use crate::context::ContextProvides;
use crate::cstyle_common::{
    ModsAccept, Quoted, TypeArgAccept, delegate_tuple_w, delegate_tuple_ws, delegate_tuple_ww,
};
use crate::{Output, Writable, WritableSeq};

impl<O, Type> Writable<O> for UseType<Type>
where
    O: Output,
    Type: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("use ").await?;
        self.0.write_to(output).await?;
        output.write(";\n").await
    }
}

impl<O, Cond, Attr> Writable<O> for CfgAttr<Cond, Attr>
where
    O: Output,
    Cond: Writable<O>,
    Attr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("cfg_attr(").await?;
        self.0.write_to(output).await?;
        output.write(", ").await?;
        self.1.write_to(output).await?;
        output.write(")").await
    }
}

impl<O, Cond> Writable<O> for Cfg<Cond>
where
    O: Output,
    Cond: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("cfg(").await?;
        self.0.write_to(output).await?;
        output.write(")").await
    }
}

impl<O, Value> Writable<O> for Doc<Value>
where
    O: Output,
    Value: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("doc(").await?;
        match self {
            Self::Hidden => output.write("hidden").await,
            Self::Inline => output.write("inline").await,
            Self::NoInline => output.write("no_inline").await,
            Self::Alias(value) => {
                AssignExpr(Str("alias"), Quoted(value))
                    .write_to(output)
                    .await
            }
            Self::Test(value) => {
                output.write("test").await?;
                ParenthesesAround(value).write_to(output).await
            }
        }?;
        output.write(")").await
    }
}

impl<O, Value> Writable<O> for Target<Value>
where
    O: Output,
    Value: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let (kind, value) = match self {
            Self::Os(value) => ("os", value),
            Self::Family(value) => ("family", value),
            Self::Arch(value) => ("arch", value),
        };
        AssignExpr(Combined(Str("target_"), Str(kind)), Quoted(value))
            .write_to(output)
            .await
    }
}

impl<O, Arg> Writable<O> for Link<Arg>
where
    O: Output,
    Arg: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("link(").await?;
        self.0.write_to(output).await?;
        output.write(")").await
    }
}

impl<O> Writable<O> for NoMangle
where
    O: Output,
    O::Ctx: ContextProvides<Edition>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let edition = output.get_ctx();
        output
            .write(if edition >= &Edition::Rust2024 {
                "unsafe(no_mangle)"
            } else {
                "no_mangle"
            })
            .await
    }
}

impl<O, Lints> Writable<O> for AllowLints<Lints>
where
    O: Output,
    Lints: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let mut acceptor = SeparatedSeqAccept::new(output, Str("allow("), Str(","));
        self.0.for_each(&mut acceptor).await?;
        if acceptor.wrote_any {
            output.write(")").await?;
        }
        Ok(())
    }
}

impl<O, Msg, Since> Writable<O> for Deprecated<Msg, Since>
where
    O: Output,
    Msg: Writable<O>,
    Since: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        match self {
            Self::Basic => output.write("deprecated").await,
            Self::Message(msg) => {
                AssignExpr(Str("deprecated"), Quoted(msg))
                    .write_to(output)
                    .await
            }
            Self::Full { since, note } => {
                NamedTuple {
                    name: Str("deprecated"),
                    args: CombinedSeq(
                        SingularSeq(AssignExpr(Str("since"), Quoted(since))),
                        SingularSeq(AssignExpr(Str("note"), Quoted(note))),
                    ),
                }
                .write_to(output)
                .await
            }
        }
    }
}

impl<O> Writable<O> for MustUse
where
    O: Output,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("must_use").await
    }
}

impl<O> Writable<O> for ModPub
where
    O: Output,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("pub").await
    }
}

impl<O> Writable<O> for ModUnsafe
where
    O: Output,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("unsafe").await
    }
}

impl<O, Abi> Writable<O> for ModUnsafeExtern<Abi>
where
    O: Output,
    Abi: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("unsafe extern \"").await?;
        self.0.write_to(output).await?;
        output.write("\"").await
    }
}

impl<O, Abi, Body> Writable<O> for ExternBlock<Abi, Body>
where
    O: Output,
    O::Ctx: ContextProvides<Edition>,
    Abi: Writable<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let edition = output.get_ctx();
        if edition >= &Edition::Rust2024 {
            output.write("unsafe ").await?;
        }
        output.write("extern \"").await?;
        self.abi.write_to(output).await?;
        output.write("\" {").await?;
        self.body.write_to(output).await?;
        output.write("}").await
    }
}

impl<O, Name, Body> Writable<O> for ModBlock<Name, Body>
where
    O: Output,
    Name: Writable<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("mod ").await?;
        self.name.write_to(output).await?;
        output.write(" {\n").await?;
        self.body.write_to(output).await?;
        output.write("}\n").await
    }
}

delegate_tuple_ww!(IfBlock);

delegate_tuple_ww!(Else);

delegate_tuple_w!(Block);

impl<O: Output, Expr> Writable<O> for UnsafeBlock<Expr>
where
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("unsafe {\n").await?;
        self.0.write_to(o).await?;
        o.write("\n}").await?;
        Ok(())
    }
}

impl<O, InputVars, Expr> Writable<O> for Closure<InputVars, Expr>
where
    O: Output,
    InputVars: WritableSeq<O>,
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("|").await?;
        self.input_vars
            .for_each(&mut SeparatedSeqAccept::comma_separated(o))
            .await?;
        o.write("| {\n").await?;
        self.inside_block.write_to(o).await?;
        o.write("\n}").await?;
        Ok(())
    }
}

impl<O: Output, Recv, FuncName, Args> Writable<O> for FunctionCall<Recv, FuncName, Args>
where
    Recv: Writable<O>,
    FuncName: Writable<O>,
    Args: WritableSeq<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.receiver.write_to(o).await?;
        o.write(if self.is_assoc { "::" } else { "." }).await?;
        self.name.write_to(o).await?;
        AnonTuple(&self.args).write_to(o).await
    }
}

impl<O: Output, Name, Args> Writable<O> for Turbofish<Name, Args>
where
    Name: Writable<O>,
    Args: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.0.write_to(output).await?;
        let mut acceptor = SeparatedSeqAccept::new(output, Str("::<"), Str(", "));
        self.1.for_each(&mut acceptor).await?;
        if acceptor.wrote_any {
            output.write(">").await?;
        }
        Ok(())
    }
}

delegate_tuple_ww!(MemberAccess);

delegate_tuple_w!(Stmt);

impl<O: Output, Variable, Expr> Writable<O> for LetStmt<Variable, Expr>
where
    Variable: Writable<O>,
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        Stmt(LetExpr(&self.0, &self.1)).write_to(o).await
    }
}

impl<O: Output, Variable, Expr> Writable<O> for LetMutStmt<Variable, Expr>
where
    Variable: Writable<O>,
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        Stmt(LetMutExpr(&self.0, &self.1)).write_to(o).await
    }
}

delegate_tuple_ww!(AssignStmt);

delegate_tuple_ww!(AssignExpr);

delegate_tuple_w!(ReturnStmt);

impl<O, Pattern, Expr> Writable<O> for LetExpr<Pattern, Expr>
where
    O: Output,
    Pattern: Writable<O>,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("let ").await?;
        AssignExpr(&self.0, &self.1).write_to(output).await
    }
}

struct LetMutExpr<Pattern, Expr>(Pattern, Expr);

impl<O, Pattern, Expr> Writable<O> for LetMutExpr<Pattern, Expr>
where
    O: Output,
    Pattern: Writable<O>,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("let mut ").await?;
        AssignExpr(&self.0, &self.1).write_to(output).await
    }
}

impl<O, Content> Writable<O> for RawStringLiteral<Content>
where
    O: Output,
    Content: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("r#\"").await?;
        self.0.write_to(output).await?;
        output.write("\"#").await
    }
}

impl<O: Output, Elements> Writable<O> for ArrayFromElements<Elements>
where
    Elements: WritableSeq<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("[").await?;
        self.0
            .for_each(&mut SeparatedSeqAccept::comma_separated(o))
            .await?;
        o.write("]").await
    }
}

impl<O: Output, Default, Count> Writable<O> for ArrayInit<Default, Count>
where
    Default: Writable<O>,
    Count: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("[").await?;
        self.0.write_to(o).await?;
        o.write("; ").await?;
        self.1.write_to(o).await?;
        o.write("]").await
    }
}

impl<O: Output, Cont, Item> Writable<O> for AssociatedItem<Cont, Item>
where
    Cont: Writable<O>,
    Item: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.0.write_to(o).await?;
        o.write("::").await?;
        self.1.write_to(o).await
    }
}

impl<O: Output, Expr> Writable<O> for QuestionMarkAfter<Expr>
where
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.0.write_to(o).await?;
        o.write("?").await
    }
}

impl<O: Output, Type, Trait> Writable<O> for TypeAsTrait<Type, Trait>
where
    Type: Writable<O>,
    Trait: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("<").await?;
        TypeAsType(&self.0, &self.1).write_to(o).await?;
        o.write(">").await
    }
}

impl<O, Type1, Type2> Writable<O> for TypeAsType<Type1, Type2>
where
    O: Output,
    Type1: Writable<O>,
    Type2: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.0.write_to(o).await?;
        o.write(" as ").await?;
        self.1.write_to(o).await
    }
}

impl<O, Mods, Name, Args, Return, Where, Body> Writable<O>
    for FunctionDef<Mods, Name, Args, Return, Where, Body>
where
    O: Output,
    Mods: WritableSeq<O>,
    Name: Writable<O>,
    Args: WritableSeq<O>,
    Return: Writable<O>,
    Where: WritableSeq<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(o)).await?;
        o.write("fn ").await?;
        self.name.write_to(o).await?;
        AnonTuple(&self.args).write_to(o).await?;
        o.write(" -> ").await?;
        self.return_type.write_to(o).await?;
        self.where_conds.for_each(&mut where_cond_accept(o)).await?;
        self.body.write_to(o).await?;
        o.write("\n\n").await
    }
}

impl<O: Output> Writable<O> for FunctionBodyDeclare {
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write(";").await
    }
}

impl<O: Output, Inner> Writable<O> for FunctionBodyImplement<Inner>
where
    Inner: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write(" ").await?;
        Block(&self.0).write_to(output).await
    }
}

impl<O, Args, Return> Writable<O> for FunctionPtr<Args, Return>
where
    O: Output,
    Args: WritableSeq<O>,
    Return: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let kind = match self.kind {
            FunctionPtrKind::FnPtr => "fn",
            FunctionPtrKind::Fn => "Fn",
            FunctionPtrKind::FnMut => "FnMut",
            FunctionPtrKind::FnOnce => "FnOnce",
        };
        output.write(kind).await?;
        AnonTuple(&self.args).write_to(output).await?;
        output.write(" -> ").await?;
        self.return_type.write_to(output).await
    }
}

impl<O: Output, Type, Value> Writable<O> for AssociatedTypeEquals<Type, Value>
where
    Type: Writable<O>,
    Value: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        AssignExpr(&self.0, &self.1).write_to(o).await
    }
}

impl<O: Output, Type> Writable<O> for DynOf<Type>
where
    Type: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("dyn ").await?;
        self.0.write_to(o).await
    }
}

impl<O: Output, Expr> Writable<O> for RefOf<Expr>
where
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("&").await?;
        self.0.write_to(o).await
    }
}

impl<O: Output, Expr> Writable<O> for RefMutOf<Expr>
where
    Expr: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("&mut ").await?;
        self.0.write_to(o).await
    }
}

impl<O, Expr> Writable<O> for Dereference<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("*").await?;
        self.0.write_to(output).await
    }
}

impl<O, Expr> Writable<O> for ParenthesesAround<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("(").await?;
        self.0.write_to(output).await?;
        output.write(")").await
    }
}

impl<O: Output, Type> Writable<O> for ImplOf<Type>
where
    Type: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("impl ").await?;
        self.0.write_to(o).await
    }
}

impl<O: Output, Type> Writable<O> for LifetimedRefOf<'_, Type>
where
    Type: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("&'").await?;
        o.write(self.0).await?;
        o.write(" ").await?;
        self.1.write_to(o).await
    }
}

impl<O, Expr> Writable<O> for RawConstOf<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("&raw const ").await?;
        self.0.write_to(output).await
    }
}

impl<O, Expr> Writable<O> for RawMutOf<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("&raw mut ").await?;
        self.0.write_to(output).await
    }
}

impl<O, Expr> Writable<O> for ConstPtr<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("*const ").await?;
        self.0.write_to(output).await
    }
}

impl<O, Expr> Writable<O> for MutPtr<Expr>
where
    O: Output,
    Expr: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("*mut ").await?;
        self.0.write_to(output).await
    }
}

impl<O, Value> Writable<O> for TypeDeclare<Value>
where
    O: Output,
    Value: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("type ").await?;
        self.0.write_to(output).await?;
        output.write(";\n\n").await
    }
}

impl<O, Mods, Name, TypeVars, SuperTraits, Body> Writable<O>
    for TraitDef<Mods, Name, TypeVars, SuperTraits, Body>
where
    O: Output,
    Mods: WritableSeq<O>,
    Name: Writable<O>,
    TypeVars: WritableSeq<O>,
    SuperTraits: WritableSeq<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(o)).await?;
        o.write("trait ").await?;
        self.name.write_to(o).await?;
        TypeArgAccept::new(o)
            .write_in_diamond(&self.type_variables)
            .await?;
        self.super_traits
            .for_each(&mut type_arg_bound_accept(o))
            .await?;
        o.write(" {\n").await?;
        self.body.write_to(o).await?;
        o.write("}\n\n").await?;
        Ok(())
    }
}

impl<O, Mods, TypeVars, Trait, Recv, Where, Body> Writable<O>
    for TraitImpl<Mods, TypeVars, Trait, Recv, Where, Body>
where
    O: Output,
    Mods: WritableSeq<O>,
    TypeVars: WritableSeq<O>,
    Trait: Writable<O>,
    Recv: Writable<O>,
    Where: WritableSeq<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        let impl_block = Impl {
            mods: &self.mods,
            type_variables: &self.type_variables,
            receiver: Combined(&self.the_trait, Combined(Str(" for "), &self.receiver)),
            where_conds: &self.where_conds,
            body: &self.body,
        };
        impl_block.write_to(output).await
    }
}

impl<O, Mods, TypeVars, Recv, Where, Body> Writable<O> for Impl<Mods, TypeVars, Recv, Where, Body>
where
    O: Output,
    Mods: WritableSeq<O>,
    TypeVars: WritableSeq<O>,
    Recv: Writable<O>,
    Where: WritableSeq<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(o)).await?;
        o.write("impl").await?;
        TypeArgAccept::new(o)
            .write_in_diamond(&self.type_variables)
            .await?;
        o.write(" ").await?;
        self.receiver.write_to(o).await?;
        self.where_conds.for_each(&mut where_cond_accept(o)).await?;
        o.write(" {\n").await?;
        self.body.write_to(o).await?;
        o.write("}\n\n").await?;
        Ok(())
    }
}

impl<O, Mods, Name, Elements> Writable<O> for StructDef<Mods, Name, Elements>
where
    O: Output,
    Mods: WritableSeq<O>,
    Name: Writable<O>,
    Elements: WritableSeq<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(o)).await?;
        o.write("struct ").await?;
        match &self.kind {
            StructKind::Tuple(name, elements) => {
                NamedTuple {
                    name,
                    args: elements,
                }
                .write_to(o)
                .await?;
                o.write(";").await
            }
            StructKind::NamedFields(name, elements) => {
                StructCall {
                    name,
                    body: StructFields(elements),
                }
                .write_to(o)
                .await
            }
        }?;
        o.write("\n\n").await
    }
}

impl<O, Name, Body> Writable<O> for StructCall<Name, Body>
where
    O: Output,
    Name: Writable<O>,
    Body: Writable<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        self.name.write_to(o).await?;
        o.write(" { ").await?;
        self.body.write_to(o).await?;
        o.write(" }").await
    }
}

impl<O, Fields> Writable<O> for StructFields<Fields>
where
    O: Output,
    Fields: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.0.for_each(&mut struct_fields_accept(output)).await
    }
}

impl<O, Mods, Name, FieldType> Writable<O> for DeclareField<Mods, Name, FieldType>
where
    O: Output,
    Mods: WritableSeq<O>,
    Name: Writable<O>,
    FieldType: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(output)).await?;
        FunctionParam(&self.name, &self.field_type)
            .write_to(output)
            .await
    }
}

impl<O, Name, Value> Writable<O> for FillOutField<Name, Value>
where
    O: Output,
    Name: Writable<O>,
    Value: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        FunctionParam(&self.0, &self.1).write_to(output).await
    }
}

impl<O, Name, Args> Writable<O> for NamedTuple<Name, Args>
where
    O: Output,
    Name: Writable<O>,
    Args: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.name.write_to(output).await?;
        // Only write the parentheses if arguments is non-empty
        let mut separator = SeparatedSeqAccept::new(output, Str("("), Str(", "));
        self.args.for_each(&mut separator).await?;
        if separator.wrote_any {
            output.write(")").await?;
        }
        Ok(())
    }
}

impl<O, Args> Writable<O> for AnonTuple<Args>
where
    O: Output,
    Args: WritableSeq<O>,
{
    async fn write_to(&self, o: &mut O) -> Result<(), O::Error> {
        o.write("(").await?;
        self.0
            .for_each(&mut SeparatedSeqAccept::comma_separated(o))
            .await?;
        o.write(")").await
    }
}

impl<O, Attr, Value> Writable<O> for WithAttributes<Attr, Value>
where
    O: Output,
    Attr: WritableSeq<O>,
    Value: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.attr
            .for_each(&mut AttributesAccept::with_separator(
                output,
                self.separator,
            ))
            .await?;
        self.value.write_to(output).await
    }
}

impl<O> Writable<O> for AttributeSeparator
where
    O: Output,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output
            .write(match self {
                AttributeSeparator::Space => " ",
                AttributeSeparator::NewLine => "\n",
            })
            .await
    }
}

impl<O, Mods, Name, Entries> Writable<O> for EnumDef<Mods, Name, Entries>
where
    O: Output,
    Mods: WritableSeq<O>,
    Name: Writable<O>,
    Entries: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.mods.for_each(&mut ModsAccept(output)).await?;
        output.write("enum ").await?;
        self.name.write_to(output).await?;
        output.write(" {").await?;
        self.entries
            .for_each(&mut SeparatedSeqAccept::comma_separated(output))
            .await?;
        output.write("}\n\n").await
    }
}

delegate_tuple_ws!(Parameterized);

impl<O, TypeVar, Bounds> Writable<O> for BoundedTypeVar<TypeVar, Bounds>
where
    O: Output,
    TypeVar: Writable<O>,
    Bounds: WritableSeq<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.0.write_to(output).await?;
        self.1.for_each(&mut type_arg_bound_accept(output)).await
    }
}

impl<O> Writable<O> for Lifetime<'_>
where
    O: Output,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        output.write("'").await?;
        output.write(self.0).await
    }
}

impl<O, Name, Type> Writable<O> for FunctionParam<Name, Type>
where
    O: Output,
    Name: Writable<O>,
    Type: Writable<O>,
{
    async fn write_to(&self, output: &mut O) -> Result<(), O::Error> {
        self.0.write_to(output).await?;
        output.write(": ").await?;
        self.1.write_to(output).await
    }
}

//
// Sequence acceptors
//

fn type_arg_bound_accept<'o, O>(
    output: &'o mut O,
) -> SeparatedSeqAccept<'o, O, Str<&'static str>, Str<&'static str>> {
    SeparatedSeqAccept::new(output, Str(": "), Str(" + "))
}

fn struct_fields_accept<'o, O>(
    output: &'o mut O,
) -> SeparatedSeqAccept<'o, O, Str<&'static str>, Str<&'static str>> {
    SeparatedSeqAccept::new(output, Str("\n"), Str(",\n"))
}

fn where_cond_accept<'o, O>(
    output: &'o mut O,
) -> SeparatedSeqAccept<'o, O, Str<&'static str>, Str<&'static str>> {
    SeparatedSeqAccept::new(output, Str(" where "), Str(", "))
}